diff --git a/.cargo/config b/.cargo/config
index 58e1381b1..0a8fd3d00 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -1,2 +1,11 @@
 [target.x86_64-unknown-redox]
 linker = "x86_64-unknown-redox-gcc"
+
+[target.'cfg(feature = "cargo-clippy")']
+rustflags = [
+  "-Wclippy::use_self",
+  "-Wclippy::needless_pass_by_value",
+  "-Wclippy::semicolon_if_nothing_returned",
+  "-Wclippy::single_char_pattern",
+  "-Wclippy::explicit_iter_loop",
+]
diff --git a/.clippy.toml b/.clippy.toml
new file mode 100644
index 000000000..0d369b50f
--- /dev/null
+++ b/.clippy.toml
@@ -0,0 +1 @@
+msrv = "1.56.0"
diff --git a/.editorconfig b/.editorconfig
index d93fa7c0e..53ccc4f9a 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,4 +1,4 @@
-# EditorConfig (is awesome): http://EditorConfig.org
+# EditorConfig (is awesome!; ref: http://EditorConfig.org; v2022.02.11 [rivy])
 
 # * top-most EditorConfig file
 root = true
@@ -13,27 +13,49 @@ insert_final_newline = true
 max_line_length = 100
 trim_trailing_whitespace = true
 
-[[Mm]akefile{,.*}, *.{mk,[Mm][Kk]}]
+[{[Mm]akefile{,.*},*.{mak,mk,[Mm][Aa][Kk],[Mm][Kk]},[Gg][Nn][Uu]makefile}]
 # makefiles ~ TAB-style indentation
 indent_style = tab
 
+[*.bash]
+# `bash` shell scripts
+indent_size = 4
+indent_style = space
+# * ref: <https://github.com/foxundermoon/vs-shell-format/blob/bc56a8e367b04bbf7d9947b767dc82516a6155b7/src/shFormat.ts>
+# shell_variant = bash ## allow `shellcheck` to decide via script hash-bang/sha-bang line
+switch_case_indent = true
+
 [*.{bat,cmd,[Bb][Aa][Tt],[Cc][Mm][Dd]}]
 # BAT/CMD ~ DOS/Win requires BAT/CMD files to have CRLF EOLNs
 end_of_line = crlf
 
+[*.{cjs,cjx,cts,ctx,js,jsx,mjs,mts,mtx,ts,tsx,json,jsonc}]
+# js/ts/json ~ Prettier/XO-style == TAB indention + SPACE alignment
+indent_size = 2
+indent_style = tab
+
 [*.go]
 # go ~ TAB-style indentation (SPACE-style alignment); ref: <https://blog.golang.org/gofmt>@@<https://archive.is/wip/9B6FC>
 indent_style = tab
 
-[*.{cjs,js,json,mjs,ts}]
-# js/ts
-indent_size = 2
-
 [*.{markdown,md,mkd,[Mm][Dd],[Mm][Kk][Dd],[Mm][Dd][Oo][Ww][Nn],[Mm][Kk][Dd][Oo][Ww][Nn],[Mm][Aa][Rr][Kk][Dd][Oo][Ww][Nn]}]
 # markdown
 indent_size = 2
 indent_style = space
 
+[*.sh]
+# POSIX shell scripts
+indent_size = 4
+indent_style = space
+# * ref: <https://github.com/foxundermoon/vs-shell-format/blob/bc56a8e367b04bbf7d9947b767dc82516a6155b7/src/shFormat.ts>
+# shell_variant = posix ## allow `shellcheck` to decide via script hash-bang/sha-bang line
+switch_case_indent = true
+
+[*.{sln,vc{,x}proj{,.*},[Ss][Ln][Nn],[Vv][Cc]{,[Xx]}[Pp][Rr][Oo][Jj]{,.*}}]
+# MSVC sln/vcproj/vcxproj files, when used, will persistantly revert to CRLF EOLNs and eat final EOLs
+end_of_line = crlf
+insert_final_newline = false
+
 [*.{yaml,yml,[Yy][Mm][Ll],[Yy][Aa][Mm][Ll]}]
 # YAML
 indent_size = 2
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..ef7519b88
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    open-pull-requests-limit: 5
diff --git a/.github/workflows/CICD.yml b/.github/workflows/CICD.yml
index d096ff43c..08803afb1 100644
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -1,11 +1,11 @@
 name: CICD
 
 # spell-checker:ignore (acronyms) CICD MSVC musl
-# spell-checker:ignore (env/flags) Awarnings Ccodegen Coverflow Cpanic RUSTDOCFLAGS RUSTFLAGS Zpanic
-# spell-checker:ignore (jargon) SHAs deps softprops toolchain
+# spell-checker:ignore (env/flags) Awarnings Ccodegen Coverflow Cpanic Dwarnings RUSTDOCFLAGS RUSTFLAGS Zpanic
+# spell-checker:ignore (jargon) SHAs deps dequote softprops subshell toolchain
 # spell-checker:ignore (names) CodeCOV MacOS MinGW Peltoche rivy
-# spell-checker:ignore (shell/tools) choco clippy dmake dpkg esac fakeroot gmake grcov halium lcov libssl mkdir popd printf pushd rustc rustfmt rustup shopt xargs
-# spell-checker:ignore (misc) aarch alnum armhf bindir busytest coreutils gnueabihf issuecomment maint nullglob onexitbegin onexitend runtest tempfile testsuite uutils
+# spell-checker:ignore (shell/tools) choco clippy dmake dpkg esac fakeroot gmake grcov halium lcov libssl mkdir popd printf pushd rsync rustc rustfmt rustup shopt xargs
+# spell-checker:ignore (misc) aarch alnum armhf bindir busytest coreutils gnueabihf issuecomment maint nullglob onexitbegin onexitend pell runtest tempfile testsuite uutils DESTDIR multisize Swatinem
 
 # ToDO: [2021-06; rivy] change from `cargo-tree` to `cargo tree` once MSRV is >= 1.45
 
@@ -13,48 +13,88 @@ env:
   PROJECT_NAME: coreutils
   PROJECT_DESC: "Core universal (cross-platform) utilities"
   PROJECT_AUTH: "uutils"
-  RUST_MIN_SRV: "1.47.0" ## MSRV v1.47.0
+  RUST_MIN_SRV: "1.56.0" ## MSRV v1.56.0
+  # * 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]
 
 jobs:
-  code_deps:
-    name: Style/dependencies
+  cargo-deny:
+    name: Style/cargo-deny
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: EmbarkStudios/cargo-deny-action@v1
+
+  style_deps:
+    ## ToDO: [2021-11-10; rivy] 'Style/deps' needs more informative output and better integration of results into the GHA dashboard
+    name: Style/deps
     runs-on: ${{ matrix.job.os }}
+    # env:
+    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
     strategy:
       fail-fast: false
       matrix:
         job:
-          - { os: ubuntu-latest , features: feat_os_unix }
+          # note: `cargo-udeps` panics when processing stdbuf/libstdbuf ("uu_stdbuf_libstdbuf"); either b/c of the 'cpp' crate or 'libstdbuf' itself
+          #   ... b/c of the panic, a more limited feature set is tested (though only excluding `stdbuf`)
+          - { os: ubuntu-latest  , features: "feat_Tier1,feat_require_unix,feat_require_unix_utmpx" }
+          - { os: macos-latest   , features: "feat_Tier1,feat_require_unix,feat_require_unix_utmpx" }
+          - { os: windows-latest , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
     - name: Initialize workflow variables
       id: vars
       shell: bash
       run: |
         ## VARs setup
         outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
         # target-specific options
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='' ;
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
         outputs CARGO_FEATURES_OPTION
+    ## note: requires 'nightly' toolchain b/c `cargo-udeps` uses the `rustc` '-Z save-analysis' option
+    ## * ... ref: <https://github.com/est31/cargo-udeps/issues/73>
     - name: Install `rust` toolchain
       uses: actions-rs/toolchain@v1
       with:
-        toolchain: stable
+        toolchain: nightly-2022-03-21
         default: true
-        profile: minimal # minimal component installation (ie, no documentation)
-    - name: "`cargo update` testing"
+        profile: minimal
+    - name: Install `cargo-udeps`
+      uses: actions-rs/install@v0.1
+      with:
+        crate: cargo-udeps
+        version: latest
+        use-tool-cache: false
+      env:
+        RUSTUP_TOOLCHAIN: stable
+    - name: Detect unused dependencies
       shell: bash
       run: |
-        ## `cargo update` testing
-        # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
-        cargo fetch --locked --quiet || { echo "::error file=Cargo.lock::'Cargo.lock' file requires update (use \`cargo +${{ env.RUST_MIN_SRV }} update\`)" ; exit 1 ; }
+        ## Detect unused dependencies
+        unset fault
+        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+        #
+        cargo +nightly-2022-03-21 udeps ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --all-targets &> udeps.log || cat udeps.log
+        grep --ignore-case "all deps seem to have been used" udeps.log || { printf "%s\n" "::${fault_type} ::${fault_prefix}: \`cargo udeps\`: style violation (unused dependency found)" ; fault=true ; }
+        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
 
-  code_format:
+  style_format:
     name: Style/format
     runs-on: ${{ matrix.job.os }}
+    # env:
+    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
     strategy:
       fail-fast: false
       matrix:
@@ -62,12 +102,19 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
     - name: Initialize workflow variables
       id: vars
       shell: bash
       run: |
         ## VARs setup
         outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
         # target-specific options
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='' ;
@@ -80,48 +127,172 @@ jobs:
         default: true
         profile: minimal # minimal component installation (ie, no documentation)
         components: rustfmt
-    - name: "`fmt` testing"
+    - name: "`cargo fmt` testing"
       shell: bash
       run: |
-        ## `fmt` testing
-        # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
-        S=$(cargo fmt -- --check) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s\n" "$S" | sed -E -n -e "s/^Diff[[:space:]]+in[[:space:]]+${PWD//\//\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*$/::error file=\1,line=\2::ERROR: \`cargo fmt\`: style violation (file:'\1', line:\2; use \`cargo fmt \"\1\"\`)/p" ; exit 1 ; }
-    - name: "`fmt` testing of tests"
+        ## `cargo fmt` testing
+        unset fault
+        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+        # * convert any errors/warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+        S=$(cargo fmt -- --check) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s\n" "$S" | sed -E -n -e "s/^Diff[[:space:]]+in[[:space:]]+${PWD//\//\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*$/::${fault_type} file=\1,line=\2::${fault_prefix}: \`cargo fmt\`: style violation (file:'\1', line:\2; use \`cargo fmt -- \"\1\"\`)/p" ; fault=true ; }
+        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+    - name: "`cargo fmt` testing of integration tests"
       if: success() || failure() # run regardless of prior step success/failure
       shell: bash
       run: |
-        ## `fmt` testing of tests
-        # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
-        S=$(find tests -name "*.rs" -print0 | xargs -0 cargo fmt -- --check) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s\n" "$S" | sed -E -n "s/^Diff[[:space:]]+in[[:space:]]+${PWD//\//\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*$/::error file=\1,line=\2::ERROR: \`cargo fmt\`: style violation (file:'\1', line:\2; use \`cargo fmt \"\1\"\`)/p" ; exit 1 ; }
+        ## `cargo fmt` testing of integration tests
+        unset fault
+        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+        # 'tests' is the standard/usual integration test directory
+        if [ -d tests ]; then
+          # * convert any errors/warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+          S=$(find tests -name "*.rs" -print0 | xargs -0 cargo fmt -- --check) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s\n" "$S" | sed -E -n "s/^Diff[[:space:]]+in[[:space:]]+${PWD//\//\\/}\/(.*)[[:space:]]+at[[:space:]]+[^0-9]+([0-9]+).*$/::${fault_type} file=\1,line=\2::${fault_prefix}: \`cargo fmt\`: style violation (file:'\1', line:\2; use \`cargo fmt \"\1\"\`)/p" ; fault=true ; }
+        fi
+        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
 
-  code_lint:
+  style_lint:
     name: Style/lint
     runs-on: ${{ matrix.job.os }}
+    # env:
+    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
     strategy:
       fail-fast: false
       matrix:
         job:
-          - { os: ubuntu-latest }
+          - { os: ubuntu-latest  , features: feat_os_unix }
           - { os: macos-latest   , features: feat_os_macos }
           - { os: windows-latest , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v2
-    - name: Install/setup prerequisites
-      shell: bash
-      run: |
-        case '${{ matrix.job.os }}' in
-          macos-latest) brew install coreutils ;; # needed for show-utils.sh
-        esac
+    - uses: Swatinem/rust-cache@v1
     - name: Initialize workflow variables
       id: vars
       shell: bash
       run: |
         ## VARs setup
         outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
         # target-specific options
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='--all-features' ;
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features ${{ matrix.job.features }}' ; fi
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        outputs CARGO_FEATURES_OPTION
+        # * determine sub-crate utility list
+        UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
+        echo UTILITY_LIST=${UTILITY_LIST}
+        CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo "-puu_${u}"; done;)"
+        outputs CARGO_UTILITY_LIST_OPTIONS
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        case '${{ matrix.job.os }}' in
+          macos-latest) brew install coreutils ;; # needed for show-utils.sh
+        esac
+    - name: Install `rust` toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        default: true
+        profile: minimal # minimal component installation (ie, no documentation)
+        components: clippy
+    - name: "`cargo clippy` lint testing"
+      shell: bash
+      run: |
+        ## `cargo clippy` lint testing
+        unset fault
+        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+        # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+        S=$(cargo clippy --all-targets ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} ${{ steps.vars.outputs.CARGO_UTILITY_LIST_OPTIONS }} -- -D warnings 2>&1) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+(.*):([0-9]+):([0-9]+).*$/::${fault_type} file=\2,line=\3,col=\4::${fault_prefix}: \`cargo clippy\`: \1 (file:'\2', line:\3)/p;" -e '}' ; fault=true ; }
+        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+
+  style_spellcheck:
+    name: Style/spelling
+    runs-on: ${{ matrix.job.os }}
+    # env:
+    #   STYLE_FAIL_ON_FAULT: false # overrides workflow default
+    strategy:
+      matrix:
+        job:
+          - { os: ubuntu-latest , features: feat_os_unix }
+    steps:
+    - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        ## VARs setup
+        outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        ## Install/setup prerequisites
+        # * pin installed cspell to v4.2.8 (cspell v5+ is broken for NodeJS < v12)
+        ## maint: [2021-11-10; rivy] `cspell` version may be advanced to v5 when used with NodeJS >= v12
+        sudo apt-get -y update ; sudo apt-get -y install npm ; sudo npm install cspell@4.2.8 -g ;
+    - name: Run `cspell`
+      shell: bash
+      run: |
+        ## Run `cspell`
+        unset fault
+        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+        # * find cspell configuration ; note: avoid quotes around ${cfg_file} b/c `cspell` (v4) doesn't correctly dequote the config argument (or perhaps a subshell expansion issue?)
+        cfg_files=($(shopt -s nullglob ; echo {.vscode,.}/{,.}c[sS]pell{.json,.config{.js,.cjs,.json,.yaml,.yml},.yaml,.yml} ;))
+        cfg_file=${cfg_files[0]}
+        unset CSPELL_CFG_OPTION ; if [ -n "$cfg_file" ]; then CSPELL_CFG_OPTION="--config $cfg_file" ; fi
+        # * `cspell`
+        ## maint: [2021-11-10; rivy] the `--no-progress` option for `cspell` is a `cspell` v5+ option
+        # S=$(cspell ${CSPELL_CFG_OPTION} --no-summary --no-progress "**/*") && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
+        S=$(cspell ${CSPELL_CFG_OPTION} --no-summary "**/*") && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
+        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+
+  doc_warnings:
+    name: Documentation/warnings
+    runs-on: ${{ matrix.job.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: ubuntu-latest  , features: feat_os_unix }
+# for now, don't build it on mac & windows because the doc is only published from linux
+# + it needs a bunch of duplication for build
+# and I don't want to add a doc step in the regular build to avoid long builds
+#          - { os: macos-latest   , features: feat_os_macos }
+#          - { os: windows-latest , features: feat_os_windows }
+    steps:
+    - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        ## VARs setup
+        outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case '${{ env.STYLE_FAIL_ON_FAULT }}' in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
+        # target-specific options
+        # * CARGO_FEATURES_OPTION
+        CARGO_FEATURES_OPTION='--all-features' ;
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
         outputs CARGO_FEATURES_OPTION
         # * determine sub-crate utility list
         UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
@@ -131,39 +302,18 @@ jobs:
     - name: Install `rust` toolchain
       uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly
+        toolchain: stable
         default: true
         profile: minimal # minimal component installation (ie, no documentation)
         components: clippy
-    - name: "`clippy` lint testing"
+    - name: "`cargo doc` with warnings"
       shell: bash
       run: |
-        ## `clippy` lint testing
-        # * convert any warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
-        S=$(cargo +nightly clippy --all-targets ${{ steps.vars.outputs.CARGO_UTILITY_LIST_OPTIONS }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -- -D warnings 2>&1) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n -e '/^error:/{' -e "N; s/^error:[[:space:]]+(.*)\\n[[:space:]]+-->[[:space:]]+${PWD//\//\\/}\/(.*):([0-9]+):([0-9]+).*$/::error file=\2,line=\3,col=\4::ERROR: \`cargo clippy\`: \1 (file:'\2', line:\3)/p;" -e '}' ; exit 1 ; }
+        RUSTDOCFLAGS="-Dwarnings" cargo doc  ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-deps --workspace --document-private-items
 
-  code_spellcheck:
-    name: Style/spelling
-    runs-on: ${{ matrix.job.os }}
-    strategy:
-      matrix:
-        job:
-          - { os: ubuntu-latest }
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install/setup prerequisites
-      shell: bash
-      run: |
-        ## Install/setup prerequisites
-        sudo apt-get -y update ; sudo apt-get -y install npm ; sudo npm install cspell -g ;
-    - name: Run `cspell`
-      shell: bash
-      run: |
-        ## Run `cspell`
-        cspell --config .vscode/cSpell.json --no-summary --no-progress "**/*" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::error file=\1,line=\2,col=\3::ERROR: \4 (file:'\1', line:\2)/p"
 
   min_version:
-    name: MinRustV # Minimum supported rust version
+    name: MinRustV # Minimum supported rust version (aka, MinSRV or MSRV)
     runs-on: ${{ matrix.job.os }}
     strategy:
       matrix:
@@ -171,6 +321,18 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        ## VARs setup
+        outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        # target-specific options
+        # * CARGO_FEATURES_OPTION
+        unset CARGO_FEATURES_OPTION
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        outputs CARGO_FEATURES_OPTION
     - name: Install `rust` toolchain (v${{ env.RUST_MIN_SRV }})
       uses: actions-rs/toolchain@v1
       with:
@@ -191,6 +353,13 @@ jobs:
         ## Confirm MinSRV compatible 'Cargo.lock'
         # * 'Cargo.lock' is required to be in a format that `cargo` of MinSRV can interpret (eg, v1-format for MinSRV < v1.38)
         cargo fetch --locked --quiet || { echo "::error file=Cargo.lock::Incompatible (or out-of-date) 'Cargo.lock' file; update using \`cargo +${{ env.RUST_MIN_SRV }} update\`" ; exit 1 ; }
+    - name: Confirm MinSRV equivalence for '.clippy.toml'
+      shell: bash
+      run: |
+        ## Confirm MinSRV equivalence for '.clippy.toml'
+        # * ensure '.clippy.toml' MSRV configuration setting is equal to ${{ env.RUST_MIN_SRV }}
+        CLIPPY_MSRV=$(grep -P "(?i)^\s*msrv\s*=\s*" .clippy.toml | grep -oP "\d+([.]\d+)+")
+        if [ "${CLIPPY_MSRV}" != "${{ env.RUST_MIN_SRV }}" ]; then { echo "::error file=.clippy.toml::Incorrect MSRV configuration for clippy (found '${CLIPPY_MSRV}'; should be '${{ env.RUST_MIN_SRV }}'); update '.clippy.toml' with 'msrv = \"${{ env.RUST_MIN_SRV }}\"'" ; exit 1 ; } ; fi
     - name: Info
       shell: bash
       run: |
@@ -208,38 +377,59 @@ jobs:
         cargo-tree tree -V
         # dependencies
         echo "## dependency list"
-        cargo fetch --locked --quiet
         ## * using the 'stable' toolchain is necessary to avoid "unexpected '--filter-platform'" errors
-        RUSTUP_TOOLCHAIN=stable cargo-tree tree --locked --all --no-dev-dependencies --no-indent --features ${{ matrix.job.features }} | grep -vE "$PWD" | sort --unique
+        RUSTUP_TOOLCHAIN=stable cargo fetch --locked --quiet
+        RUSTUP_TOOLCHAIN=stable cargo-tree tree --all --locked --no-dev-dependencies --no-indent ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} | grep -vE "$PWD" | sort --unique
     - name: Test
       uses: actions-rs/cargo@v1
       with:
         command: test
-        args: --features "feat_os_unix" -p uucore -p coreutils
+        args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
       env:
-        RUSTFLAGS: '-Awarnings'
+        RUSTFLAGS: "-Awarnings"
 
-  build_makefile:
-    name: Build/Makefile
+  deps:
+    name: Dependencies
     runs-on: ${{ matrix.job.os }}
     strategy:
       fail-fast: false
       matrix:
         job:
-          - { os: ubuntu-latest }
+          - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
     - name: Install `rust` toolchain
       uses: actions-rs/toolchain@v1
       with:
         toolchain: stable
         default: true
         profile: minimal # minimal component installation (ie, no documentation)
-    - name: Install/setup prerequisites
+    - name: "`cargo update` testing"
       shell: bash
       run: |
-        ## Install/setup prerequisites
-        sudo apt-get -y update ; sudo apt-get -y install python3-sphinx ;
+        ## `cargo update` testing
+        # * convert any errors/warnings to GHA UI annotations; ref: <https://help.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message>
+        cargo fetch --locked --quiet || { echo "::error file=Cargo.lock::'Cargo.lock' file requires update (use \`cargo +${{ env.RUST_MIN_SRV }} update\`)" ; exit 1 ; }
+
+  build_makefile:
+    name: Build/Makefile
+    needs: [ min_version, deps ]
+    runs-on: ${{ matrix.job.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: ubuntu-latest , features: feat_os_unix }
+    steps:
+    - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Install `rust` toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        default: true
+        profile: minimal # minimal component installation (ie, no documentation)
     - name: "`make build`"
       shell: bash
       run: |
@@ -249,42 +439,137 @@ jobs:
       run: |
         make test
 
-  build:
-    name: Build
+
+  build_rust_stable:
+    name: Build/stable
+    needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
     strategy:
       fail-fast: false
       matrix:
         job:
-          # { os, target, cargo-options, features, use-cross, toolchain }
-          - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf , features: feat_os_unix_gnueabihf , use-cross: use-cross }
+          - { os: ubuntu-latest  , features: feat_os_unix }
+          - { os: macos-latest   , features: feat_os_macos }
+          - { os: windows-latest , features: feat_os_windows }
+    steps:
+    - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Install `rust` toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        default: true
+        profile: minimal # minimal component installation (ie, no documentation)
+    - name: Test
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+
+  build_rust_nightly:
+    name: Build/nightly
+    needs: [ min_version, deps ]
+    runs-on: ${{ matrix.job.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: ubuntu-latest  , features: feat_os_unix }
+          - { os: macos-latest   , features: feat_os_macos }
+          - { os: windows-latest , features: feat_os_windows }
+    steps:
+    - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Install `rust` toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly-2022-03-21
+        default: true
+        profile: minimal # minimal component installation (ie, no documentation)
+    - name: Test
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+
+  compute_size:
+    name: Binary sizes
+    needs: [ min_version, deps ]
+    runs-on: ${{ matrix.job.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: ubuntu-latest , features: feat_os_unix }
+    steps:
+    - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Install dependencies
+      shell: bash
+      run: |
+        ## Install dependencies
+        sudo apt-get update
+        sudo apt-get install jq
+    - name: Install `rust` toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        default: true
+        profile: minimal # minimal component installation (ie, no documentation)
+    - name: "`make install`"
+      shell: bash
+      run: |
+        make install DESTDIR=target/size-release/
+        make install MULTICALL=y DESTDIR=target/size-multi-release/
+        # strip the results
+        strip target/size*/usr/local/bin/*
+    - name: "Compute sizes"
+      shell: bash
+      run: |
+        SIZE=$(du -s target/size-release/usr/local/bin/|awk '{print $1}')
+        SIZEMULTI=$(du -s target/size-multi-release/usr/local/bin/|awk '{print $1}')
+        jq -n \
+              --arg date "$(date --rfc-email)" \
+              --arg sha "$GITHUB_SHA" \
+              --arg size "$SIZE" \
+              --arg multisize "$SIZEMULTI" \
+              '{($date): { sha: $sha, size: $size, multisize: $multisize, }}' > size-result.json
+    - uses: actions/upload-artifact@v2
+      with:
+        name: size-result
+        path: size-result.json
+
+  build:
+    name: Build
+    needs: [ min_version, deps ]
+    runs-on: ${{ matrix.job.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          # { os , target , cargo-options , features , use-cross , toolchain }
+          - { 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: x86_64-unknown-linux-gnu    , features: feat_os_unix           , use-cross: use-cross }
           # - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: feat_selinux           , use-cross: use-cross }
           # - { os: ubuntu-18.04   , target: i586-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross } ## note: older windows platform; not required, dev-FYI only
           # - { os: ubuntu-18.04   , target: i586-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross } ## note: older windows platform; not required, dev-FYI only
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-musl     , features: feat_os_unix_musl      , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-gnu    , features: feat_os_unix           , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-musl   , features: feat_os_unix_musl      , 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 }
+          # Commented until https://github.com/uutils/coreutils/issues/3210 is fixed
+          #- { os: ubuntu-18.04   , target: i686-unknown-linux-gnu      , features: feat_os_unix           , use-cross: use-cross }
+          #- { os: ubuntu-18.04   , target: i686-unknown-linux-musl     , features: feat_os_unix_musl      , use-cross: use-cross }
+          #- { os: ubuntu-18.04   , target: x86_64-unknown-linux-gnu    , features: feat_os_unix           , use-cross: use-cross }
+          #- { os: ubuntu-18.04   , target: x86_64-unknown-linux-musl   , features: feat_os_unix_musl      , use-cross: use-cross }
           - { os: macos-latest   , target: x86_64-apple-darwin         , features: feat_os_macos }
-          - { os: windows-latest , target: i686-pc-windows-gnu         , features: feat_os_windows }
           - { os: windows-latest , target: i686-pc-windows-msvc        , features: feat_os_windows }
-          - { os: windows-latest , target: x86_64-pc-windows-gnu       , features: feat_os_windows }  ## note: requires rust >= 1.43.0 to link correctly
+          - { os: windows-latest , target: x86_64-pc-windows-gnu       , features: feat_os_windows } ## note: requires rust >= 1.43.0 to link correctly
           - { os: windows-latest , target: x86_64-pc-windows-msvc      , features: feat_os_windows }
     steps:
     - uses: actions/checkout@v2
-    - name: Install/setup prerequisites
-      shell: bash
-      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 ;;
-        esac
-        case '${{ matrix.job.os }}' in
-          macos-latest) brew install coreutils ;; # needed for testing
-        esac
+    - uses: Swatinem/rust-cache@v1
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -353,7 +638,7 @@ jobs:
         # target-specific options
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='' ;
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features=${{ matrix.job.features }}' ; fi
         outputs CARGO_FEATURES_OPTION
         # * CARGO_USE_CROSS (truthy)
         CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;
@@ -380,14 +665,36 @@ jobs:
         mkdir -p '${{ steps.vars.outputs.STAGING }}'
         mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'
         mkdir -p '${{ steps.vars.outputs.STAGING }}/dpkg'
+    - name: Install/setup prerequisites
+      shell: bash
+      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 ;;
+        esac
+        case '${{ matrix.job.os }}' in
+          macos-latest) brew install coreutils ;; # needed for testing
+        esac
+        case '${{ matrix.job.os }}' in
+          ubuntu-*)
+            # pinky is a tool to show logged-in users from utmp, and gecos fields from /etc/passwd.
+            # In GitHub Action *nix VMs, no accounts log in, even the "runner" account that runs the commands. The account also has empty gecos fields.
+            # To work around this for pinky tests, we create a fake login entry for the GH runner account...
+            FAKE_UTMP='[7] [999999] [tty2] [runner] [tty2] [] [0.0.0.0] [2022-02-22T22:22:22,222222+00:00]'
+            # ... by dumping the login records, adding our fake line, then reverse dumping ...
+            (utmpdump /var/run/utmp ; echo $FAKE_UTMP) | sudo utmpdump -r -o /var/run/utmp
+            # ... and add a full name to each account with a gecos field but no full name.
+            sudo sed -i 's/:,/:runner name,/' /etc/passwd
+            # We also create a couple optional files pinky looks for
+            touch /home/runner/.project
+            echo "foo" > /home/runner/.plan
+            ;;
+        esac
     - name: rust toolchain ~ install
       uses: actions-rs/toolchain@v1
-      env:
-        # Override auto-detection of RAM for Rustc install.
-        # https://github.com/rust-lang/rustup/issues/2229#issuecomment-585855925
-        RUSTUP_UNPACK_RAM: "21474836480"
       with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
+        toolchain: ${{ env.RUST_MIN_SRV }}
         target: ${{ matrix.job.target }}
         default: true
         profile: minimal # minimal component installation (ie, no documentation)
@@ -398,7 +705,7 @@ jobs:
         ## Dependent VARs setup
         outputs() { step_id="dep_vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
         # * determine sub-crate utility list
-        UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
+        UTILITY_LIST="$(./util/show-utils.sh ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }})"
         echo UTILITY_LIST=${UTILITY_LIST}
         CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo "-puu_${u}"; done;)"
         outputs CARGO_UTILITY_LIST_OPTIONS
@@ -439,18 +746,21 @@ jobs:
         use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
         command: build
         args: --release --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+        toolchain: ${{ env.RUST_MIN_SRV }}
     - name: Test
       uses: actions-rs/cargo@v1
       with:
         use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
         command: test
         args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+        toolchain: ${{ env.RUST_MIN_SRV }}
     - name: Test individual utilities
       uses: actions-rs/cargo@v1
       with:
         use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
         command: test
         args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
+        toolchain: ${{ env.RUST_MIN_SRV }}
     - name: Archive executable artifacts
       uses: actions/upload-artifact@v2
       with:
@@ -502,6 +812,7 @@ jobs:
 
   test_busybox:
     name: Tests/BusyBox test suite
+    needs: [ min_version, deps ]
     runs-on: ${{ matrix.job.os }}
     strategy:
       fail-fast: false
@@ -510,16 +821,18 @@ jobs:
           - { os: ubuntu-latest }
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        ## Install/setup prerequisites
+        make prepare-busytest
     - name: Install `rust` toolchain
       uses: actions-rs/toolchain@v1
       with:
         toolchain: stable
         default: true
         profile: minimal # minimal component installation (ie, no documentation)
-    - name: Install/setup prerequisites
-      shell: bash
-      run: |
-        make prepare-busytest
     - name: "Run BusyBox test suite"
       shell: bash
       run: |
@@ -532,71 +845,87 @@ jobs:
         if [ $n_fails -gt 0 ] ; then echo "::warning ::${n_fails}+ test failures" ; fi
 
   test_freebsd:
-    runs-on: macos-latest
     name: Tests/FreeBSD test suite
+    needs: [ min_version, deps ]
+    runs-on: ${{ matrix.job.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: macos-10.15 , 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>
     env:
       mem: 2048
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
     - name: Prepare, build and test
-      id: test
+      ## spell-checker:ignore (ToDO) sshfs usesh vmactions
       uses: vmactions/freebsd-vm@v0.1.5
       with:
         usesh: true
+        # sync: sshfs
         prepare: pkg install -y curl gmake sudo
         run: |
-          # Need to be run in the same block. Otherwise, we are back on the mac host.
+          ## Prepare, build, and test
+          # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
+          # * NOTE: All steps need to be run in this block, otherwise, we are operating back on the mac host
           set -e
-          pw adduser -n cuuser -d /root/ -g wheel -c "Coreutils user to build" -w random
-          chown -R cuuser:wheel /root/ /Users/runner/work/coreutils/
+          #
+          TEST_USER=tester
+          REPO_NAME=${GITHUB_WORKSPACE##*/}
+          WORKSPACE_PARENT="/Users/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}"/
           whoami
-
-          # Needs to be done in a sudo as we are changing users
-          sudo -i -u cuuser sh << EOF
+          #
+          # Further work needs to be done in a sudo as we are changing users
+          sudo -i -u ${TEST_USER} sh << EOF
           set -e
           whoami
           curl https://sh.rustup.rs -sSf --output rustup.sh
           sh rustup.sh -y --profile=minimal
+          . $HOME/.cargo/env
           ## Info
           # environment
           echo "## environment"
           echo "CI='${CI}'"
-          # tooling info display
-          echo "## tooling"
-          . $HOME/.cargo/env
+          echo "REPO_NAME='${REPO_NAME}'"
+          echo "TEST_USER='${TEST_USER}'"
+          echo "WORKSPACE_PARENT='${WORKSPACE_PARENT}'"
+          echo "WORKSPACE='${WORKSPACE}'"
+          env | sort
+          # tooling info
+          echo "## tooling info"
           cargo -V
           rustc -V
-          env
-
-          # where the files are resynced
-          cd /Users/runner/work/coreutils/coreutils/
-          cargo build
-          cargo test --features feat_os_unix -p uucore -p coreutils
+          #
+          cd "${WORKSPACE}"
+          unset FAULT
+          cargo build || FAULT=1
+          cargo test --features "${{ matrix.job.features }}" || FAULT=1
+          cargo test --features "${{ matrix.job.features }}" -p uucore || FAULT=1
           # Clean to avoid to rsync back the files
           cargo clean
+          if (test -n "$FAULT"); then exit 1 ; fi
           EOF
 
-
   coverage:
     name: Code Coverage
+    needs: build
     runs-on: ${{ matrix.job.os }}
     strategy:
       fail-fast: true
       matrix:
-        # job: [ { os: ubuntu-latest }, { os: macos-latest }, { os: windows-latest } ]
         job:
           - { os: ubuntu-latest  , features: unix }
           - { os: macos-latest   , features: macos }
           - { os: windows-latest , features: windows }
     steps:
     - uses: actions/checkout@v2
-    - name: Install/setup prerequisites
-      shell: bash
-      run: |
-        ## Install/setup prerequisites
-        case '${{ matrix.job.os }}' in
-          macos-latest) brew install coreutils ;; # needed for testing
-        esac
+    - uses: Swatinem/rust-cache@v1
     # - name: Reattach HEAD ## may be needed for accurate code coverage info
     #   run: git checkout ${{ github.head_ref }}
     - name: Initialize workflow variables
@@ -606,7 +935,7 @@ jobs:
         ## VARs setup
         outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
         # toolchain
-        TOOLCHAIN="nightly" ## default to "nightly" toolchain (required for certain required unstable compiler flags) ## !maint: refactor when stable channel has needed support
+        TOOLCHAIN="nightly-2022-03-21" ## default to "nightly" toolchain (required for certain required unstable compiler flags) ## !maint: refactor when stable channel has needed support
         # * specify gnu-type TOOLCHAIN for windows; `grcov` requires gnu-style code coverage data files
         case ${{ matrix.job.os }} in windows-*) TOOLCHAIN="$TOOLCHAIN-x86_64-pc-windows-gnu" ;; esac;
         # * use requested TOOLCHAIN if specified
@@ -615,19 +944,36 @@ jobs:
         # staging directory
         STAGING='_staging'
         outputs STAGING
-        ## # check for CODECOV_TOKEN availability (work-around for inaccessible 'secrets' object for 'if'; see <https://github.community/t5/GitHub-Actions/jobs-lt-job-id-gt-if-does-not-work-with-env-secrets/m-p/38549>)
-        ## # note: CODECOV_TOKEN / HAS_CODECOV_TOKEN is not needed for public repositories when using AppVeyor, Azure Pipelines, CircleCI, GitHub Actions, Travis (see <https://docs.codecov.io/docs/about-the-codecov-bash-uploader#section-upload-token>)
-        ## unset HAS_CODECOV_TOKEN
-        ## if [ -n $CODECOV_TOKEN ]; then HAS_CODECOV_TOKEN='true' ; fi
-        ## outputs HAS_CODECOV_TOKEN
         # target-specific options
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='--all-features' ;  ## default to '--all-features' for code coverage
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features=${{ matrix.job.features }}' ; fi
         outputs CARGO_FEATURES_OPTION
         # * CODECOV_FLAGS
         CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
         outputs CODECOV_FLAGS
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        ## Install/setup prerequisites
+        case '${{ matrix.job.os }}' in
+          macos-latest) brew install coreutils ;; # needed for testing
+        esac
+        case '${{ matrix.job.os }}' in
+          ubuntu-latest)
+            # pinky is a tool to show logged-in users from utmp, and gecos fields from /etc/passwd.
+            # In GitHub Action *nix VMs, no accounts log in, even the "runner" account that runs the commands. The account also has empty gecos fields.
+            # To work around this for pinky tests, we create a fake login entry for the GH runner account...
+            FAKE_UTMP='[7] [999999] [tty2] [runner] [tty2] [] [0.0.0.0] [2022-02-22T22:22:22,222222+00:00]'
+            # ... by dumping the login records, adding our fake line, then reverse dumping ...
+            (utmpdump /var/run/utmp ; echo $FAKE_UTMP) | sudo utmpdump -r -o /var/run/utmp
+            # ... and add a full name to each account with a gecos field but no full name.
+            sudo sed -i 's/:,/:runner name,/' /etc/passwd
+            # We also create a couple optional files pinky looks for
+            touch /home/runner/.project
+            echo "foo" > /home/runner/.plan
+            ;;
+        esac
     - name: rust toolchain ~ install
       uses: actions-rs/toolchain@v1
       with:
@@ -641,7 +987,7 @@ jobs:
         ## Dependent VARs setup
         outputs() { step_id="dep_vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
         # * determine sub-crate utility list
-        UTILITY_LIST="$(./util/show-utils.sh ${CARGO_FEATURES_OPTION})"
+        UTILITY_LIST="$(./util/show-utils.sh ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }})"
         CARGO_UTILITY_LIST_OPTIONS="$(for u in ${UTILITY_LIST}; do echo "-puu_${u}"; done;)"
         outputs CARGO_UTILITY_LIST_OPTIONS
     - name: Test uucore
@@ -650,10 +996,10 @@ jobs:
         command: test
         args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast -p uucore
       env:
-        CARGO_INCREMENTAL: '0'
-        RUSTC_WRAPPER: ''
-        RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort'
-        RUSTDOCFLAGS: '-Cpanic=abort'
+        CARGO_INCREMENTAL: "0"
+        RUSTC_WRAPPER: ""
+        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTDOCFLAGS: "-Cpanic=abort"
         # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
     - name: Test
       uses: actions-rs/cargo@v1
@@ -661,10 +1007,10 @@ jobs:
         command: test
         args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast
       env:
-        CARGO_INCREMENTAL: '0'
-        RUSTC_WRAPPER: ''
-        RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort'
-        RUSTDOCFLAGS: '-Cpanic=abort'
+        CARGO_INCREMENTAL: "0"
+        RUSTC_WRAPPER: ""
+        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTDOCFLAGS: "-Cpanic=abort"
         # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
     - name: Test individual utilities
       uses: actions-rs/cargo@v1
@@ -672,10 +1018,10 @@ jobs:
         command: test
         args: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-fail-fast ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
       env:
-        CARGO_INCREMENTAL: '0'
-        RUSTC_WRAPPER: ''
-        RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort'
-        RUSTDOCFLAGS: '-Cpanic=abort'
+        CARGO_INCREMENTAL: "0"
+        RUSTC_WRAPPER: ""
+        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTDOCFLAGS: "-Cpanic=abort"
         # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
     - name: "`grcov` ~ install"
       uses: actions-rs/install@v0.1
@@ -690,13 +1036,13 @@ jobs:
         ## Generate coverage data
         COVERAGE_REPORT_DIR="target/debug"
         COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
-        # GRCOV_IGNORE_OPTION='--ignore build.rs --ignore "/*" --ignore "[a-zA-Z]:/*"' ## `grcov` ignores these params when passed as an environment variable (why?)
+        # GRCOV_IGNORE_OPTION='--ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*"' ## `grcov` ignores these params when passed as an environment variable (why?)
         # GRCOV_EXCLUDE_OPTION='--excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"' ## `grcov` ignores these params when passed as an environment variable (why?)
         mkdir -p "${COVERAGE_REPORT_DIR}"
         # display coverage files
-        grcov . --output-type files --ignore build.rs --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
+        grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
         # generate coverage report
-        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
+        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
         echo ::set-output name=report::${COVERAGE_REPORT_FILE}
     - name: Upload coverage results (to Codecov.io)
       uses: codecov/codecov-action@v1
@@ -708,35 +1054,3 @@ jobs:
         flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
         name: codecov-umbrella
         fail_ci_if_error: false
-
-  unused_deps:
-    name: Unused deps
-    runs-on: ${{ matrix.job.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        job:
-          - { os: ubuntu-latest , features: feat_os_unix }
-          - { os: macos-latest   , features: feat_os_macos }
-          - { os: windows-latest , features: feat_os_windows }
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install `rust` toolchain
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: nightly
-        default: true
-        profile: minimal
-    - name: Install `cargo-udeps`
-      uses: actions-rs/install@v0.1
-      with:
-        crate: cargo-udeps
-        version: latest
-        use-tool-cache: true
-      env:
-        RUSTUP_TOOLCHAIN: stable
-    - name: Confirms there isn't any unused deps
-      shell: bash
-      run: |
-        cargo +nightly udeps --all-targets &> udeps.log || cat udeps.log
-        grep "seem to have been used" udeps.log
diff --git a/.github/workflows/FixPR.yml b/.github/workflows/FixPR.yml
index d3f8a86b8..2a5382e27 100644
--- a/.github/workflows/FixPR.yml
+++ b/.github/workflows/FixPR.yml
@@ -1,18 +1,20 @@
 name: FixPR
 
+# spell-checker:ignore Swatinem
+
 # Trigger automated fixes for PRs being merged (with associated commits)
 
 # ToDO: [2021-06; rivy] change from `cargo-tree` to `cargo tree` once MSRV is >= 1.45
 
 env:
-  BRANCH_TARGET: master
+  BRANCH_TARGET: main
 
 on:
   # * only trigger on pull request closed to specific branches
   # ref: https://github.community/t/trigger-workflow-only-on-pull-request-merge/17359/9
   pull_request:
     branches:
-      - master # == env.BRANCH_TARGET ## unfortunately, env context variables are only available in jobs/steps (see <https://github.community/t/how-to-use-env-context/16975/2>)
+      - main # == env.BRANCH_TARGET ## unfortunately, env context variables are only available in jobs/steps (see <https://github.community/t/how-to-use-env-context/16975/2>)
     types: [ closed ]
 
 jobs:
@@ -27,6 +29,7 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
     - name: Initialize job variables
       id: vars
       shell: bash
@@ -98,6 +101,7 @@ jobs:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
     - uses: actions/checkout@v2
+    - uses: Swatinem/rust-cache@v1
     - name: Initialize job variables
       id: vars
       shell: bash
diff --git a/.github/workflows/GnuTests.yml b/.github/workflows/GnuTests.yml
index dad53f20c..579bea4c0 100644
--- a/.github/workflows/GnuTests.yml
+++ b/.github/workflows/GnuTests.yml
@@ -1,6 +1,8 @@
 name: GnuTests
 
-# spell-checker:ignore (names) gnulib ; (utils) autopoint gperf pyinotify texinfo ; (vars) XPASS
+# spell-checker:ignore (names) gnulib ; (jargon) submodules ; (people) Dawid Dziurla * dawidd ; (utils) autopoint chksum gperf pyinotify shopt texinfo ; (vars) FILESET SUBDIRS XPASS
+
+# * note: to run a single test => `REPO/util/run-gnu-test.sh PATH/TO/TEST/SCRIPT`
 
 on: [push, pull_request]
 
@@ -9,23 +11,52 @@ jobs:
     name: Run GNU tests
     runs-on: ubuntu-latest
     steps:
-    - name: Checkout code uutil
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        ## VARs setup
+        outputs() { step_id="vars"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        # * config
+        path_GNU="gnu"
+        path_GNU_tests="${path_GNU}/tests"
+        path_UUTILS="uutils"
+        path_reference="reference"
+        outputs path_GNU path_GNU_tests path_reference path_UUTILS
+        #
+        repo_default_branch="${{ github.event.repository.default_branch }}"
+        repo_GNU_ref="v9.0"
+        repo_reference_branch="${{ github.event.repository.default_branch }}"
+        outputs repo_default_branch repo_GNU_ref repo_reference_branch
+        #
+        SUITE_LOG_FILE="${path_GNU_tests}/test-suite.log"
+        TEST_LOGS_GLOB="${path_GNU_tests}/**/*.log" ## note: not usable at bash CLI; [why] double globstar not enabled by default b/c MacOS includes only bash v3 which doesn't have double globstar support
+        TEST_FILESET_PREFIX='test-fileset-IDs.sha1#'
+        TEST_FILESET_SUFFIX='.txt'
+        TEST_SUMMARY_FILE='gnu-result.json'
+        TEST_FULL_SUMMARY_FILE='gnu-full-result.json'
+        outputs SUITE_LOG_FILE TEST_FILESET_PREFIX TEST_FILESET_SUFFIX TEST_LOGS_GLOB TEST_SUMMARY_FILE TEST_FULL_SUMMARY_FILE
+    - name: Checkout code (uutil)
       uses: actions/checkout@v2
       with:
-        path: 'uutils'
-    - name: Checkout GNU coreutils
+        path: '${{ steps.vars.outputs.path_UUTILS }}'
+    - name: Checkout code (GNU coreutils)
       uses: actions/checkout@v2
       with:
         repository: 'coreutils/coreutils'
-        path: 'gnu'
-        ref: v8.32
-    - name: Checkout GNU coreutils library (gnulib)
-      uses: actions/checkout@v2
+        path: '${{ steps.vars.outputs.path_GNU }}'
+        ref: ${{ steps.vars.outputs.repo_GNU_ref }}
+        submodules: recursive
+    - name: Retrieve reference artifacts
+      uses: dawidd6/action-download-artifact@v2
+      # 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:
-        repository: 'coreutils/gnulib'
-        path: 'gnulib'
-        ref: 8e99f24c0931a38880c6ee9b8287c7da80b0036b
-        fetch-depth: 0 # gnu gets upset if gnulib is a shallow checkout
+        workflow: GnuTests.yml
+        branch: "${{ steps.vars.outputs.repo_reference_branch }}"
+        # workflow_conclusion: success ## (default); * but, if commit with failed GnuTests is merged into the default branch, future commits will all show regression errors in GnuTests CI until o/w fixed
+        workflow_conclusion: completed ## continually recalibrates to last commit of default branch with a successful GnuTests (ie, "self-heals" from GnuTest regressions, but needs more supervision for/of regressions)
+        path: "${{ steps.vars.outputs.path_reference }}"
     - name: Install `rust` toolchain
       uses: actions-rs/toolchain@v1
       with:
@@ -38,35 +69,58 @@ jobs:
       run: |
         ## Install dependencies
         sudo apt-get update
-        sudo apt-get install autoconf autopoint bison texinfo gperf gcc g++ gdb python-pyinotify python3-sphinx jq
+        sudo apt-get install autoconf autopoint bison texinfo gperf gcc g++ gdb python-pyinotify jq valgrind libexpect-perl
+    - name: Add various locales
+      shell: bash
+      run: |
+        echo "Before:"
+        locale -a
+        ## Some tests fail with 'cannot change locale (en_US.ISO-8859-1): No such file or directory'
+        ## Some others need a French locale
+        sudo locale-gen
+        sudo locale-gen fr_FR
+        sudo locale-gen fr_FR.UTF-8
+        sudo update-locale
+        echo "After:"
+        locale -a
     - name: Build binaries
       shell: bash
       run: |
         ## Build binaries
-        cd uutils
+        cd '${{ steps.vars.outputs.path_UUTILS }}'
         bash util/build-gnu.sh
     - name: Run GNU tests
       shell: bash
       run: |
-        bash uutils/util/run-gnu-test.sh
-    - name: Extract testing info
+        path_GNU='${{ steps.vars.outputs.path_GNU }}'
+        path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
+        bash "${path_UUTILS}/util/run-gnu-test.sh"
+    - name: Extract testing info into JSON
+      shell: bash
+      run : |
+        path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
+        python ${path_UUTILS}/util/gnu-json-result.py ${{ steps.vars.outputs.path_GNU_tests }} > ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
+    - name: Extract/summarize testing info
+      id: summary
       shell: bash
       run: |
-        ## Extract testing info
-        LOG_FILE=gnu/tests/test-suite.log
-        if test -f "$LOG_FILE"
+        ## Extract/summarize testing info
+        outputs() { step_id="summary"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo ::set-output name=${var}::${!var}; done; }
+        #
+        SUITE_LOG_FILE='${{ steps.vars.outputs.SUITE_LOG_FILE }}'
+        if test -f "${SUITE_LOG_FILE}"
         then
-            TOTAL=$(sed -n "s/.*# TOTAL: \(.*\)/\1/p"  "$LOG_FILE"|tr -d '\r'|head -n1)
-            PASS=$(sed -n "s/.*# PASS: \(.*\)/\1/p" "$LOG_FILE"|tr -d '\r'|head -n1)
-            SKIP=$(sed -n "s/.*# SKIP: \(.*\)/\1/p" "$LOG_FILE"|tr -d '\r'|head -n1)
-            FAIL=$(sed -n "s/.*# FAIL: \(.*\)/\1/p" "$LOG_FILE"|tr -d '\r'|head -n1)
-            XPASS=$(sed -n "s/.*# XPASS: \(.*\)/\1/p" "$LOG_FILE"|tr -d '\r'|head -n1)
-            ERROR=$(sed -n "s/.*# ERROR: \(.*\)/\1/p" "$LOG_FILE"|tr -d '\r'|head -n1)
+            TOTAL=$(sed -n "s/.*# TOTAL: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
+            PASS=$(sed -n "s/.*# PASS: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
+            SKIP=$(sed -n "s/.*# SKIP: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
+            FAIL=$(sed -n "s/.*# FAIL: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
+            XPASS=$(sed -n "s/.*# XPASS: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
+            ERROR=$(sed -n "s/.*# ERROR: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
             if [[ "$TOTAL" -eq 0 || "$TOTAL" -eq 1 ]]; then
-               echo "Error in the execution, failing early"
-               exit 1
+              echo "::error ::Failed to parse test results from '${SUITE_LOG_FILE}'; failing early"
+              exit 1
             fi
-            output="GNU tests summary = TOTAL: $TOTAL / PASS: $PASS / FAIL: $FAIL / ERROR: $ERROR"
+            output="GNU tests summary = TOTAL: $TOTAL / PASS: $PASS / FAIL: $FAIL / ERROR: $ERROR / SKIP: $SKIP"
             echo "${output}"
             if [[ "$FAIL" -gt 0 || "$ERROR" -gt 0 ]]; then echo "::warning ::${output}" ; fi
             jq -n \
@@ -78,54 +132,149 @@ jobs:
                   --arg fail "$FAIL" \
                   --arg xpass "$XPASS" \
                   --arg error "$ERROR" \
-                  '{($date): { sha: $sha, total: $total, pass: $pass, skip: $skip, fail: $fail, xpass: $xpass, error: $error, }}' > gnu-result.json
+                  '{($date): { sha: $sha, total: $total, pass: $pass, skip: $skip, fail: $fail, xpass: $xpass, error: $error, }}' > '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}'
+            HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
+            outputs HASH
           else
-            echo "::error ::Failed to get summary of test results"
+            echo "::error ::Failed to find summary of test results (missing '${SUITE_LOG_FILE}'); failing early"
+            exit 1
           fi
-    - uses: actions/upload-artifact@v2
+          # Compress logs before upload (fails otherwise)
+          gzip ${{ steps.vars.outputs.TEST_LOGS_GLOB }}
+    - name: Reserve SHA1/ID of 'test-summary'
+      uses: actions/upload-artifact@v2
       with:
-        name: test-report
-        path: gnu/tests/**/*.log
-    - uses: actions/upload-artifact@v2
+        name: "${{ steps.summary.outputs.HASH }}"
+        path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
+    - name: Reserve test results summary
+      uses: actions/upload-artifact@v2
       with:
-        name: gnu-result
-        path: gnu-result.json
-    - name: Download the result
-      uses: dawidd6/action-download-artifact@v2
+        name: test-summary
+        path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
+    - name: Reserve test logs
+      uses: actions/upload-artifact@v2
       with:
-        workflow: GnuTests.yml
-        name: gnu-result
-        repo: uutils/coreutils
-        branch: master
-        path: dl
-    - name: Download the log
-      uses: dawidd6/action-download-artifact@v2
+        name: test-logs
+        path: "${{ steps.vars.outputs.TEST_LOGS_GLOB }}"
+    - name: Upload full json results
+      uses: actions/upload-artifact@v2
       with:
-        workflow: GnuTests.yml
-        name: test-report
-        repo: uutils/coreutils
-        branch: master
-        path: dl
-    - name: Compare failing tests against master
+        name: gnu-full-result.json
+        path: ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
+    - name: Compare test failures VS reference
       shell: bash
       run: |
-            OLD_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" dl/test-suite.log | sort)
-            NEW_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" gnu/tests/test-suite.log | sort)
-            for LINE in $OLD_FAILING
-            do
-              if ! grep -Fxq $LINE<<<"$NEW_FAILING"; then
-                echo "::warning ::Congrats! The gnu test $LINE is now passing!"
-              fi
-            done
-            for LINE in $NEW_FAILING
-            do
-              if ! grep -Fxq $LINE<<<"$OLD_FAILING"
-              then
-                echo "::error ::GNU test failed: $LINE. $LINE is passing on 'master'. Maybe you have to rebase?"
-              fi
-            done
-    - name: Compare against master results
+        have_new_failures=""
+        REF_LOG_FILE='${{ steps.vars.outputs.path_reference }}/test-logs/test-suite.log'
+        REF_SUMMARY_FILE='${{ steps.vars.outputs.path_reference }}/test-summary/gnu-result.json'
+        REPO_DEFAULT_BRANCH='${{ steps.vars.outputs.repo_default_branch }}'
+        if test -f "${REF_LOG_FILE}"; then
+          echo "Reference SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
+          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
+              echo "::warning ::Congrats! The gnu test ${LINE} is no longer failing!"
+            fi
+          done
+          for LINE in ${NEW_FAILING}
+          do
+            if ! grep -Fxq ${LINE}<<<"${REF_FAILING}"
+            then
+              echo "::error ::GNU test failed: ${LINE}. ${LINE} is passing on '${{ steps.vars.outputs.repo_default_branch }}'. Maybe you have to rebase?"
+              have_new_failures="true"
+            fi
+          done
+        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: Compare test summary VS reference
+      if: success() || failure() # run regardless of prior step success/failure
       shell: bash
       run: |
-        mv dl/gnu-result.json master-gnu-result.json
-        python uutils/util/compare_gnu_result.py
+        REF_SUMMARY_FILE='${{ steps.vars.outputs.path_reference }}/test-summary/gnu-result.json'
+        if test -f "${REF_SUMMARY_FILE}"; then
+          echo "Reference SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
+          mv "${REF_SUMMARY_FILE}" main-gnu-result.json
+          python uutils/util/compare_gnu_result.py
+        else
+          echo "::warning ::Skipping test summary comparison; no prior reference summary is available."
+        fi
+
+  gnu_coverage:
+    name: Run GNU tests with coverage
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code uutil
+      uses: actions/checkout@v2
+      with:
+        path: 'uutils'
+    - name: Checkout GNU coreutils
+      uses: actions/checkout@v2
+      with:
+        repository: 'coreutils/coreutils'
+        path: 'gnu'
+        ref: 'v9.0'
+        submodules: recursive
+    - name: Install `rust` toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly-2022-03-21
+        default: true
+        profile: minimal # minimal component installation (ie, no documentation)
+        components: rustfmt
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt install autoconf autopoint bison texinfo gperf gcc g++ gdb python-pyinotify jq valgrind libexpect-perl -y
+    - name: Add various locales
+      run: |
+        echo "Before:"
+        locale -a
+        ## Some tests fail with 'cannot change locale (en_US.ISO-8859-1): No such file or directory'
+        ## Some others need a French locale
+        sudo locale-gen
+        sudo locale-gen fr_FR
+        sudo locale-gen fr_FR.UTF-8
+        sudo update-locale
+        echo "After:"
+        locale -a
+    - name: Build binaries
+      env:
+        CARGO_INCREMENTAL: "0"
+        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+        RUSTDOCFLAGS: "-Cpanic=abort"
+      run: |
+        cd uutils
+        UU_MAKE_PROFILE=debug bash util/build-gnu.sh
+    - name: Run GNU tests
+      run: bash uutils/util/run-gnu-test.sh
+    - name: "`grcov` ~ install"
+      uses: actions-rs/install@v0.1
+      with:
+        crate: grcov
+        version: latest
+        use-tool-cache: false
+    - name: Generate coverage data (via `grcov`)
+      id: coverage
+      run: |
+        ## Generate coverage data
+        cd uutils
+        COVERAGE_REPORT_DIR="target/debug"
+        COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
+        mkdir -p "${COVERAGE_REPORT_DIR}"
+        sudo chown -R "$(whoami)" "${COVERAGE_REPORT_DIR}"
+        # display coverage files
+        grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
+        # generate coverage report
+        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
+        echo ::set-output name=report::${COVERAGE_REPORT_FILE}
+    - name: Upload coverage results (to Codecov.io)
+      uses: codecov/codecov-action@v2
+      with:
+        file: ${{ steps.coverage.outputs.report }}
+        flags: gnutests
+        name: gnutests
+        working-directory: uutils
diff --git a/.rustfmt.toml b/.rustfmt.toml
new file mode 100644
index 000000000..2a0c75141
--- /dev/null
+++ b/.rustfmt.toml
@@ -0,0 +1 @@
+# * using all default `cargo fmt`/`rustfmt` options
diff --git a/.travis/redox-toolchain.sh b/.travis/redox-toolchain.sh
index 83bc8fc45..d8b43b489 100755
--- a/.travis/redox-toolchain.sh
+++ b/.travis/redox-toolchain.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 
 rustup target add x86_64-unknown-redox
 sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys AA12E97F0881517F
diff --git a/.vscode/.gitattributes b/.vscode/.gitattributes
new file mode 100644
index 000000000..c050fbbf3
--- /dev/null
+++ b/.vscode/.gitattributes
@@ -0,0 +1,2 @@
+# Configure GitHub to not mark comments in configuration files as errors
+*.json linguist-language=jsonc
diff --git a/.vscode/cSpell.json b/.vscode/cSpell.json
index 498360139..6dfb3b666 100644
--- a/.vscode/cSpell.json
+++ b/.vscode/cSpell.json
@@ -1,7 +1,12 @@
 // `cspell` settings
 {
-  "version": "0.1", // Version of the setting file.  Always 0.1
-  "language": "en", // language - current active spelling language
+  // version of the setting file
+  "version": "0.2",
+
+  // spelling language
+  "language": "en",
+
+  // custom dictionaries
   "dictionaries": ["acronyms+names", "jargon", "people", "shell", "workspace"],
   "dictionaryDefinitions": [
     { "name": "acronyms+names", "path": "./cspell.dictionaries/acronyms+names.wordlist.txt" },
@@ -10,10 +15,19 @@
     { "name": "shell", "path": "./cspell.dictionaries/shell.wordlist.txt" },
     { "name": "workspace", "path": "./cspell.dictionaries/workspace.wordlist.txt" }
   ],
-  // ignorePaths -  a list of globs to specify which files are to be ignored
-  "ignorePaths": ["Cargo.lock", "target/**", "tests/**/fixtures/**", "src/uu/dd/test-resources/**"],
-  // ignoreWords - a list of words to be ignored (even if they are in the flagWords)
+
+  // files to ignore (globs supported)
+  "ignorePaths": [
+    "Cargo.lock",
+    "target/**",
+    "tests/**/fixtures/**",
+    "src/uu/dd/test-resources/**",
+    "vendor/**"
+  ],
+
+  // words to ignore (even if they are in the flagWords)
   "ignoreWords": [],
-  // words - list of words to be always considered correct
+
+  // words to always consider correct
   "words": []
 }
diff --git a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
index a46448a32..81bc3bc5f 100644
--- a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
+++ b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
@@ -35,6 +35,7 @@ WASM
 XFS
 aarch
 flac
+impls
 lzma
 
 # * names
@@ -47,6 +48,7 @@ EditorConfig
 FreeBSD
 Gmail
 GNU
+Illumos
 Irix
 MS-DOS
 MSDOS
diff --git a/.vscode/cspell.dictionaries/jargon.wordlist.txt b/.vscode/cspell.dictionaries/jargon.wordlist.txt
index 9b1d0a8da..13f340f6a 100644
--- a/.vscode/cspell.dictionaries/jargon.wordlist.txt
+++ b/.vscode/cspell.dictionaries/jargon.wordlist.txt
@@ -11,6 +11,7 @@ canonicalize
 canonicalizing
 codepoint
 codepoints
+codegen
 colorizable
 colorize
 coprime
@@ -28,6 +29,7 @@ devs
 discoverability
 duplicative
 dsync
+endianness
 enqueue
 errored
 executable
@@ -36,6 +38,8 @@ exponentiate
 eval
 falsey
 fileio
+filesystem
+filesystems
 flamegraph
 fullblock
 getfacl
@@ -59,6 +63,7 @@ kibibytes
 libacl
 lcase
 lossily
+lstat
 mebi
 mebibytes
 mergeable
diff --git a/.vscode/cspell.dictionaries/workspace.wordlist.txt b/.vscode/cspell.dictionaries/workspace.wordlist.txt
index d37a59465..99ac20ea2 100644
--- a/.vscode/cspell.dictionaries/workspace.wordlist.txt
+++ b/.vscode/cspell.dictionaries/workspace.wordlist.txt
@@ -25,6 +25,7 @@ getrandom
 globset
 itertools
 lscolors
+mdbook
 memchr
 multifilereader
 onig
@@ -43,6 +44,7 @@ termsize
 termwidth
 textwrap
 thiserror
+ureq
 walkdir
 winapi
 xattr
@@ -182,6 +184,7 @@ getgrgid
 getgrnam
 getgrouplist
 getgroups
+getpwent
 getpwnam
 getpwuid
 getuid
@@ -321,6 +324,7 @@ ucommand
 utmpx
 uucore
 uucore_procs
+uudoc
 uumain
 uutil
 uutils
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index 46b105d37..bd9dcf485 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,12 +1,13 @@
+// spell-checker:ignore (misc) matklad
+// see <http://go.microsoft.com/fwlink/?LinkId=827846> for the documentation about the extensions.json format
+// *
+// "foxundermoon.shell-format" ~ shell script formatting ; note: ENABLE "Use EditorConfig"
+// "matklad.rust-analyzer" ~ `rust` language support
+// "streetsidesoftware.code-spell-checker" ~ `cspell` spell-checker support
 {
-  // spell-checker:ignore (misc) matklad
-  // see <http://go.microsoft.com/fwlink/?LinkId=827846> for the documentation about the extensions.json format
-  "recommendations": [
-    // Rust language support.
-    "rust-lang.rust",
-    // Provides support for rust-analyzer: novel LSP server for the Rust programming language.
-    "matklad.rust-analyzer",
-    // `cspell` spell-checker support
-    "streetsidesoftware.code-spell-checker"
-  ]
+	"recommendations": [
+		"matklad.rust-analyzer",
+		"streetsidesoftware.code-spell-checker",
+		"foxundermoon.shell-format"
+	]
 }
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 000000000..54df63a5b
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1 @@
+{ "cSpell.import": [".vscode/cspell.json"] }
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2a8a80315..15adfe488 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Contributing to coreutils
 
-Contributions are very welcome, and should target Rust's master branch until the
+Contributions are very welcome, and should target Rust's main branch until the
 standard libraries are stabilized. You may *claim* an item on the to-do list by
 following these steps:
 
@@ -94,6 +94,16 @@ uutils: add new utility
 gitignore: add temporary files
 ```
 
+## cargo-deny
+
+This project uses [cargo-deny](https://github.com/EmbarkStudios/cargo-deny/) to
+detect duplicate dependencies, checks licenses, etc. To run it locally, first
+install it and then run with:
+
+```
+cargo deny --all-features check all
+```
+
 ## Licensing
 
 uutils is distributed under the terms of the MIT License; see the `LICENSE` file
diff --git a/Cargo.lock b/Cargo.lock
index 2d6a40df9..02ab122b0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,6 +8,12 @@ version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
 
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
 [[package]]
 name = "ahash"
 version = "0.4.7"
@@ -20,7 +26,7 @@ version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
 dependencies = [
- "memchr 2.4.0",
+ "memchr 2.4.1",
 ]
 
 [[package]]
@@ -29,15 +35,6 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
 
-[[package]]
-name = "ansi_term"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
-dependencies = [
- "winapi 0.3.9",
-]
-
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -55,9 +52,9 @@ checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
 
 [[package]]
 name = "arrayvec"
-version = "0.5.2"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
 
 [[package]]
 name = "atty"
@@ -76,6 +73,23 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 
+[[package]]
+name = "base64"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
+
+[[package]]
+name = "bigdecimal"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6aaf33151a6429fe9211d1b276eafdf70cdff28b071e76c0b0e1503221ea3744"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "binary-heap-plus"
 version = "0.4.1"
@@ -87,65 +101,38 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.59.1"
+version = "0.59.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "453c49e5950bb0eb63bb3df640e31618846c89d5b7faa54040d76e98e0134375"
+checksum = "2bd2a9a458e8f4304c52c43ebb0cfbd520289f8379a52e329a38afda99bf8eb8"
 dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
- "clap",
- "env_logger 0.8.4",
+ "clap 2.34.0",
+ "env_logger 0.9.0",
  "lazy_static",
  "lazycell",
  "log",
  "peeking_take_while",
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
  "regex",
  "rustc-hash",
  "shlex",
  "which",
 ]
 
-[[package]]
-name = "bit-set"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e11e16035ea35e4e5997b393eacbf6f63983188f7a2ad25bfb13465f5ad59de"
-dependencies = [
- "bit-vec",
-]
-
-[[package]]
-name = "bit-vec"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
-
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
-[[package]]
-name = "bitvec"
-version = "0.19.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8942c8d352ae1838c9dda0b0ca2ab657696ef2232a20147cf1b30ae1a9cb4321"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
 [[package]]
 name = "blake2b_simd"
-version = "0.5.11"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afa748e348ad3be8263be728124b24a24f268266f6f5d58af9d75f6a40b5c587"
+checksum = "72936ee4afc7f8f736d1c38383b56480b5497b4617b4a77bdbf1d2ababc76127"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -153,37 +140,50 @@ dependencies = [
 ]
 
 [[package]]
-name = "block-buffer"
-version = "0.2.0"
+name = "blake3"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1339a1042f5d9f295737ad4d9a6ab6bf81c84a933dba110b9200cd6d1448b814"
+checksum = "a08e53fc5a564bb15bfe6fae56bd71522205f1f91893f9c0116edad6496c183f"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if 1.0.0",
+ "constant_time_eq",
+ "digest",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1d36a02058e76b040de25a4464ba1c80935655595b661505c8b39b664828b95"
 dependencies = [
- "byte-tools",
  "generic-array",
 ]
 
 [[package]]
 name = "bstr"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90682c8d613ad3373e66de8c6411e0ae2ab2571e879d2efbf73558cc66f21279"
+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
 dependencies = [
  "lazy_static",
- "memchr 2.4.0",
+ "memchr 2.4.1",
  "regex-automata",
 ]
 
 [[package]]
-name = "byte-tools"
-version = "0.2.0"
+name = "bumpalo"
+version = "3.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
+checksum = "a4a45a46ab1f2412e53d3a0ade76ffad2025804294569aae387231a0cd6e0899"
 
 [[package]]
 name = "byte-unit"
-version = "4.0.12"
+version = "4.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063197e6eb4b775b64160dedde7a0986bb2836cce140e9492e9e96f28e18bcd8"
+checksum = "956ffc5b0ec7d7a6949e3f21fd63ba5af4cffdc2ba1e0b7bf62b481458c4ae7f"
 dependencies = [
  "utf8-width",
 ]
@@ -202,15 +202,15 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "cc"
-version = "1.0.69"
+version = "1.0.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"
 
 [[package]]
 name = "cexpr"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db507a7679252d2276ed0dd8113c6875ec56d3089f9225b2b42c30cc1f8e5c89"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
 dependencies = [
  "nom",
 ]
@@ -241,10 +241,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "clang-sys"
-version = "1.2.0"
+name = "chunked_transfer"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "853eda514c284c2287f4bf20ae614f8781f40a81d32ecda6e91449304dfe077c"
+checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e"
+
+[[package]]
+name = "clang-sys"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa66045b9cb23c2e9c1520732030608b02ee07e5cfaa5a521ec15ded7fa24c90"
 dependencies = [
  "glob",
  "libc",
@@ -253,27 +259,43 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "2.33.3"
+version = "2.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
 dependencies = [
- "ansi_term 0.11.0",
+ "ansi_term",
  "atty",
  "bitflags",
- "strsim",
- "term_size",
+ "strsim 0.8.0",
  "textwrap 0.11.0",
  "unicode-width",
  "vec_map",
 ]
 
 [[package]]
-name = "cloudabi"
-version = "0.0.3"
+name = "clap"
+version = "3.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+checksum = "d8c93436c21e4698bacadf42917db28b23017027a4deccb35dbe47a7e7840123"
 dependencies = [
+ "atty",
  "bitflags",
+ "indexmap",
+ "lazy_static",
+ "os_str_bytes",
+ "strsim 0.10.0",
+ "termcolor",
+ "terminal_size",
+ "textwrap 0.15.0",
+]
+
+[[package]]
+name = "clap_complete"
+version = "3.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df6f3613c0a3cddfd78b41b10203eb322cb29b600cbdf808a7d3db95691b8e25"
+dependencies = [
+ "clap 3.1.6",
 ]
 
 [[package]]
@@ -299,28 +321,33 @@ dependencies = [
 
 [[package]]
 name = "coreutils"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "atty",
  "chrono",
- "clap",
+ "clap 3.1.6",
+ "clap_complete",
  "conv",
  "filetime",
  "glob",
+ "hex-literal",
  "lazy_static",
  "libc",
- "nix 0.20.0",
+ "nix",
+ "phf",
+ "phf_codegen",
  "pretty_assertions",
- "rand 0.7.3",
+ "rand",
  "regex",
  "rlimit",
  "selinux",
  "sha1",
  "tempfile",
- "textwrap 0.14.2",
+ "textwrap 0.15.0",
  "time",
  "unindent",
  "unix_socket",
+ "ureq",
  "users",
  "uu_arch",
  "uu_base32",
@@ -424,6 +451,7 @@ dependencies = [
  "uu_yes",
  "uucore",
  "walkdir",
+ "zip",
 ]
 
 [[package]]
@@ -494,7 +522,7 @@ dependencies = [
  "if_rust_version",
  "lazy_static",
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
  "syn",
 ]
 
@@ -530,10 +558,28 @@ dependencies = [
 ]
 
 [[package]]
-name = "crossbeam-channel"
-version = "0.5.1"
+name = "cpufeatures"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
+checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e54ea8bc3fb1ee042f5aace6e3c6e025d3874866da222930f70ce62aceba0bfa"
 dependencies = [
  "cfg-if 1.0.0",
  "crossbeam-utils",
@@ -552,9 +598,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.5"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
+checksum = "97242a70df9b89a65d0b6df3c4bf5b9ce03c5b7309019777fbde37e7537f8762"
 dependencies = [
  "cfg-if 1.0.0",
  "crossbeam-utils",
@@ -565,9 +611,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
+checksum = "cfcae03edb34f947e64acdb1c33ec169824e20657e9ecb61cef6c8c74dcb8120"
 dependencies = [
  "cfg-if 1.0.0",
  "lazy_static",
@@ -575,14 +621,14 @@ dependencies = [
 
 [[package]]
 name = "crossterm"
-version = "0.20.0"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ebde6a9dd5e331cd6c6f48253254d117642c31653baa475e394657c59c1f7d"
+checksum = "f1fd7173631a4e9e2ca8b32ae2fad58aab9843ea5aaf56642661937d87e28a3e"
 dependencies = [
  "bitflags",
  "crossterm_winapi",
  "libc",
- "mio 0.7.7",
+ "mio 0.7.14",
  "parking_lot",
  "signal-hook",
  "signal-hook-mio",
@@ -591,30 +637,40 @@ dependencies = [
 
 [[package]]
 name = "crossterm_winapi"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a6966607622438301997d3dac0d2f6e9a90c68bb6bc1785ea98456ab93c0507"
+checksum = "2ae1b35a484aa10e07fe0638d02301c5ad24de82d310ccbd2f3693da5f09bf1c"
 dependencies = [
  "winapi 0.3.9",
 ]
 
 [[package]]
-name = "ctor"
-version = "0.1.20"
+name = "crypto-common"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e98e2ad1a782e33928b96fc3948e7c355e5af34ba4de7670fe8bac2a3b2006d"
+checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
 dependencies = [
- "quote 1.0.9",
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "ctor"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa"
+dependencies = [
+ "quote 1.0.14",
  "syn",
 ]
 
 [[package]]
 name = "ctrlc"
-version = "3.1.9"
+version = "3.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "232295399409a8b7ae41276757b5a1cc21032848d42bff2352261f958b3ca29a"
+checksum = "a19c6cedffdc8c03a3346d723eb20bd85a13362bb96dc2ac000842c6381ec7bf"
 dependencies = [
- "nix 0.20.0",
+ "nix",
  "winapi 0.3.9",
 ]
 
@@ -650,17 +706,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "derivative"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
-dependencies = [
- "proc-macro2",
- "quote 1.0.9",
- "syn",
-]
-
 [[package]]
 name = "diff"
 version = "0.1.12"
@@ -669,11 +714,13 @@ checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
 
 [[package]]
 name = "digest"
-version = "0.6.1"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecae1c064e29fcabb6c2e9939e53dc7da72ed90234ae36ebfe03a478742efbd1"
+checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"
 dependencies = [
- "generic-array",
+ "block-buffer",
+ "crypto-common",
+ "subtle",
 ]
 
 [[package]]
@@ -682,14 +729,14 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68df3f2b690c1b86e65ef7830956aededf3cb0a16f898f79b9a6f421a7b6211b"
 dependencies = [
- "rand 0.8.4",
+ "rand",
 ]
 
 [[package]]
 name = "dns-lookup"
-version = "1.0.5"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "093d88961fd18c4ecacb8c80cd0b356463ba941ba11e0e01f9cf5271380b79dc"
+checksum = "53ecafc952c4528d9b51a458d1a8904b81783feff9fde08ab6ed2545ff396872"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -711,9 +758,9 @@ checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
 
 [[package]]
 name = "env_logger"
-version = "0.7.1"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
 dependencies = [
  "log",
  "regex",
@@ -721,9 +768,9 @@ dependencies = [
 
 [[package]]
 name = "env_logger"
-version = "0.8.4"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
+checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
 dependencies = [
  "atty",
  "humantime",
@@ -734,24 +781,24 @@ dependencies = [
 
 [[package]]
 name = "exacl"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "769bbd173781e84865b957cf83449f0d2869f4c9d2f191cbbffffb3d9751ba2b"
+checksum = "9d5d9a2fa7d72579802c22bb97c37953cf1007f21f7ac2247d150c4c2d40c2ab"
 dependencies = [
  "bitflags",
  "log",
- "nix 0.21.0",
- "num_enum",
  "scopeguard",
- "serde",
  "uuid",
 ]
 
 [[package]]
-name = "fake-simd"
-version = "0.1.2"
+name = "fastrand"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
+checksum = "779d043b6a0b90cc4c0ed7ee380a6504394cee7efd7db050e3774eee387324b2"
+dependencies = [
+ "instant",
+]
 
 [[package]]
 name = "file_diff"
@@ -771,12 +818,34 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "flate2"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6988e897c1c9c485f43b47a529cef42fde0547f9d8d41a7062518f1d8fc53f"
+dependencies = [
+ "cfg-if 1.0.0",
+ "crc32fast",
+ "libc",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "form_urlencoded"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
+dependencies = [
+ "matches",
+ "percent-encoding",
+]
+
 [[package]]
 name = "fs_extra"
 version = "1.2.0"
@@ -802,59 +871,30 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "fuchsia-cprng"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
-
-[[package]]
-name = "funty"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7"
-
 [[package]]
 name = "gcd"
-version = "2.0.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c7cd301bf2ab11ae4e5bdfd79c221d97a25e46c089144a62ee9d09cb32d2b92"
+checksum = "f37978dab2ca789938a83b2f8bc1ef32db6633af9051a6cd409eff72cbaaa79a"
+dependencies = [
+ "paste",
+]
 
 [[package]]
 name = "generic-array"
-version = "0.8.4"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2297fb0e3ea512e380da24b52dca3924028f59df5e3a17a18f81d8349ca7ebe"
+checksum = "fd48d33ec7f05fbfa152300fdad764757cbded343c1aa1cff2fbaf4134851803"
 dependencies = [
- "nodrop",
  "typenum",
-]
-
-[[package]]
-name = "getopts"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
-dependencies = [
- "unicode-width",
+ "version_check",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.1.16"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "wasi 0.9.0+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+checksum = "418d37c8b1d42553c93648be529cb70f920d3baf8ef469b74b9638df426e0b4c"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -867,24 +907,11 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
 
-[[package]]
-name = "globset"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
-dependencies = [
- "aho-corasick",
- "bstr",
- "fnv",
- "log",
- "regex",
-]
-
 [[package]]
 name = "half"
-version = "1.7.1"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62aca2aba2d62b4a7f5b33f3712cb1b0692779a56fb510499d5c0aa594daeaf3"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
 
 [[package]]
 name = "hashbrown"
@@ -895,6 +922,12 @@ dependencies = [
  "ahash",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
 [[package]]
 name = "heck"
 version = "0.3.3"
@@ -915,9 +948,15 @@ dependencies = [
 
 [[package]]
 name = "hex"
-version = "0.2.0"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6a22814455d41612f41161581c2883c0c6a1c41852729b17d5ed88f01e153aa"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hex-literal"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
 
 [[package]]
 name = "hostname"
@@ -936,12 +975,33 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
+[[package]]
+name = "idna"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+dependencies = [
+ "matches",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
 [[package]]
 name = "if_rust_version"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46dbcb333e86939721589d25a3557e180b52778cb33c7fdfe9e0158ff790d5ec"
 
+[[package]]
+name = "indexmap"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.11.2",
+]
+
 [[package]]
 name = "inotify"
 version = "0.9.4"
@@ -964,37 +1024,43 @@ dependencies = [
 
 [[package]]
 name = "instant"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bee0328b1209d157ef001c94dd85b4f8f64139adb0eac2659f4b08382b2f474d"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
 dependencies = [
  "cfg-if 1.0.0",
 ]
 
 [[package]]
 name = "ioctl-sys"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c429fffa658f288669529fc26565f728489a2e39bc7b24a428aaaf51355182e"
+checksum = "8bd11f3a29434026f5ff98c730b668ba74b1033637b8817940b54d040696133c"
 
 [[package]]
 name = "itertools"
-version = "0.8.2"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f56a2d0bc861f9165be4eb3442afd3c236d8a98afd426f65d92324ae1091a484"
+checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
 dependencies = [
  "either",
 ]
 
 [[package]]
-name = "itertools"
-version = "0.10.1"
+name = "js-sys"
+version = "0.3.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf"
+checksum = "a38fc24e30fd564ce974c02bf1d337caddff65be6cc4735a1f7eab22a7440f04"
 dependencies = [
- "either",
+ "wasm-bindgen",
 ]
 
+[[package]]
+name = "keccak"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
+
 [[package]]
 name = "kernel32-sys"
 version = "0.2.2"
@@ -1039,15 +1105,15 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.101"
+version = "0.2.121"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cb00336871be5ed2c8ed44b60ae9959dc5b9f08539422ed43f09e34ecaeba21"
+checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f"
 
 [[package]]
 name = "libloading"
-version = "0.7.0"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f84d96438c15fcd6c3f244c8fce01d1e2b9c6b5623e9c711dc9286d8fc92d6a"
+checksum = "efbc0f03f9a775e9f6aed295c6a1ba2253c5757a9e03d55c6caa46a681abcddd"
 dependencies = [
  "cfg-if 1.0.0",
  "winapi 0.3.9",
@@ -1055,9 +1121,9 @@ dependencies = [
 
 [[package]]
 name = "lock_api"
-version = "0.4.4"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0382880606dff6d15c9476c416d18690b72742aa7b605bb6dd6ec9030fbf07eb"
+checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
 dependencies = [
  "scopeguard",
 ]
@@ -1077,7 +1143,7 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d24b894c45c9da468621cdd615a5a79ee5e5523dd4f75c76ebc03d458940c16e"
 dependencies = [
- "ansi_term 0.12.1",
+ "ansi_term",
 ]
 
 [[package]]
@@ -1087,16 +1153,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
 
 [[package]]
-name = "maybe-uninit"
-version = "2.0.0"
+name = "matches"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
 
 [[package]]
-name = "md5"
-version = "0.3.8"
+name = "md-5"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79c56d6a0b07f9e19282511c83fc5b086364cbae4ba8c7d5f190c3d9b0425a48"
+checksum = "658646b21e0b72f7866c7038ab086d3d5e1cd6271f060fd37defb241949d0582"
+dependencies = [
+ "digest",
+]
 
 [[package]]
 name = "memchr"
@@ -1109,33 +1178,49 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.4.0"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
 
 [[package]]
 name = "memmap2"
-version = "0.5.0"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4647a11b578fead29cdbb34d4adef8dd3dc35b876c9c6d5240d83f205abfe96e"
+checksum = "057a3db23999c867821a7a59feb06a578fcb03685e983dff90daf9e7d24ac08f"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "memoffset"
-version = "0.6.4"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
-name = "mio"
-version = "0.7.7"
+name = "minimal-lexical"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e50ae3f04d169fcc9bde0b547d1c205219b7157e07ded9c5aff03e0637cb3ed7"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
+dependencies = [
+ "adler",
+ "autocfg",
+]
+
+[[package]]
+name = "mio"
+version = "0.7.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc"
 dependencies = [
  "libc",
  "log",
@@ -1169,33 +1254,9 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.19.1"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ccba0cfe4fdf15982d1674c69b1fd80bad427d293849982668dfe454bd61f2"
-dependencies = [
- "bitflags",
- "cc",
- "cfg-if 1.0.0",
- "libc",
-]
-
-[[package]]
-name = "nix"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa9b4819da1bc61c0ea48b63b7bc8604064dd43013e7cc325df098d49cd7c18a"
-dependencies = [
- "bitflags",
- "cc",
- "cfg-if 1.0.0",
- "libc",
-]
-
-[[package]]
-name = "nix"
-version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c3728fec49d363a50a8828a190b379a446cc5cf085c06259bbbeb34447e4ec7"
+checksum = "9f866317acbd3a240710c63f065ffb1e4fd466259045ccb504130b7f668f35c6"
 dependencies = [
  "bitflags",
  "cc",
@@ -1204,21 +1265,14 @@ dependencies = [
  "memoffset",
 ]
 
-[[package]]
-name = "nodrop"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
-
 [[package]]
 name = "nom"
-version = "6.1.2"
+version = "7.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2"
+checksum = "1b1d11e1ef389c76fe5b81bcaf2ea32cf88b62bc494e19f493d0b30e7a930109"
 dependencies = [
- "bitvec",
- "funty",
- "memchr 2.4.0",
+ "memchr 2.4.1",
+ "minimal-lexical",
  "version_check",
 ]
 
@@ -1251,9 +1305,9 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74e768dff5fb39a41b3bcd30bb25cf989706c90d028d1ad71971987aa309d535"
+checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
 dependencies = [
  "autocfg",
  "num-integer",
@@ -1281,36 +1335,14 @@ dependencies = [
 
 [[package]]
 name = "num_cpus"
-version = "1.13.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
+checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
 dependencies = [
  "hermit-abi",
  "libc",
 ]
 
-[[package]]
-name = "num_enum"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9bd055fb730c4f8f4f57d45d35cd6b3f0980535b056dc7ff119cee6a66ed6f"
-dependencies = [
- "derivative",
- "num_enum_derive",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "486ea01961c4a818096de679a8b740b26d9033146ac5291b1c98557658f8cdd9"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote 1.0.9",
- "syn",
-]
-
 [[package]]
 name = "number_prefix"
 version = "0.4.0"
@@ -1325,15 +1357,15 @@ checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
 
 [[package]]
 name = "once_cell"
-version = "1.8.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
+checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"
 
 [[package]]
 name = "onig"
-version = "4.3.3"
+version = "6.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8518fcb2b1b8c2f45f0ad499df4fda6087fc3475ca69a185c173b8315d2fb383"
+checksum = "67ddfe2c93bb389eea6e6d713306880c7f6dcc99a75b659ce145d962c861b225"
 dependencies = [
  "bitflags",
  "lazy_static",
@@ -1343,9 +1375,9 @@ dependencies = [
 
 [[package]]
 name = "onig_sys"
-version = "69.1.0"
+version = "69.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388410bf5fa341f10e58e6db3975f4bea1ac30247dd79d37a9e5ced3cb4cc3b0"
+checksum = "5dd3eee045c84695b53b20255bb7317063df090b68e18bfac0abb6c39cf7f33e"
 dependencies = [
  "cc",
  "pkg-config",
@@ -1358,14 +1390,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c672c7ad9ec066e428c00eb917124a06f08db19e2584de982cc34b1f4c12485"
 dependencies = [
  "dlv-list",
- "hashbrown",
+ "hashbrown 0.9.1",
+]
+
+[[package]]
+name = "os_display"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "748cc1d0dc55247316a5bedd8dc8c5478c8a0c2e2001176b38ce7c0ed732c7a5"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "os_str_bytes"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+dependencies = [
+ "memchr 2.4.1",
 ]
 
 [[package]]
 name = "ouroboros"
-version = "0.10.1"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84236d64f1718c387232287cf036eb6632a5ecff226f4ff9dccb8c2b79ba0bde"
+checksum = "9f31a3b678685b150cba82b702dcdc5e155893f63610cf388d30cd988d4ca2bf"
 dependencies = [
  "aliasable",
  "ouroboros_macro",
@@ -1374,14 +1424,14 @@ dependencies = [
 
 [[package]]
 name = "ouroboros_macro"
-version = "0.10.1"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f463857a6eb96c0136b1d56e56c718350cef30412ec065b48294799a088bca68"
+checksum = "084fd65d5dd8b3772edccb5ffd1e4b7eba43897ecd0f9401e330e8c542959408"
 dependencies = [
  "Inflector",
  "proc-macro-error",
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
  "syn",
 ]
 
@@ -1396,47 +1446,32 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.11.1"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d7744ac029df22dca6284efe4e898991d28e3085c706c972bcd7da4a27a15eb"
+checksum = "87f5ec2493a61ac0506c0f4199f99070cbe83857b0337006a30f3e6719b8ef58"
 dependencies = [
- "instant",
  "lock_api",
  "parking_lot_core",
 ]
 
 [[package]]
 name = "parking_lot_core"
-version = "0.8.3"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7a782938e745763fe6907fc6ba86946d72f49fe7e21de074e08128a99fb018"
+checksum = "28141e0cc4143da2443301914478dc976a61ffdb3f043058310c70df2fed8954"
 dependencies = [
  "cfg-if 1.0.0",
- "instant",
  "libc",
  "redox_syscall",
- "smallvec 1.6.1",
- "winapi 0.3.9",
+ "smallvec",
+ "windows-sys",
 ]
 
 [[package]]
 name = "paste"
-version = "0.1.18"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45ca20c77d80be666aef2b45486da86238fabe33e38306bd3118fe4af33fa880"
-dependencies = [
- "paste-impl",
- "proc-macro-hack",
-]
-
-[[package]]
-name = "paste-impl"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d95a7db200b97ef370c8e6de0088252f7e0dfff7d047a28528e47456c0fc98b6"
-dependencies = [
- "proc-macro-hack",
-]
+checksum = "0744126afe1a6dd7f394cb50a716dbe086cb06e255e53d8d0185d82828358fb5"
 
 [[package]]
 name = "peeking_take_while"
@@ -1445,16 +1480,60 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
 
 [[package]]
-name = "pkg-config"
-version = "0.3.19"
+name = "percent-encoding"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
+checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+
+[[package]]
+name = "phf"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"
 
 [[package]]
 name = "platform-info"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16ea9cd21d89bffb387b6c7363d23bead0807be9de676c671b474dd29e7436d3"
+checksum = "84332c4de03d567e6f5ea143e35e63ceed534a34f768218aabf57879d7edf2a0"
 dependencies = [
  "libc",
  "winapi 0.3.9",
@@ -1462,32 +1541,22 @@ dependencies = [
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.10"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
 
 [[package]]
 name = "pretty_assertions"
-version = "0.7.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cab0e7c02cf376875e9335e0ba1da535775beb5450d21e1dffca068818ed98b"
+checksum = "ec0cfe1b2403f172ba0f234e500906ee0a3e493fb81092dac23ebefe129301cc"
 dependencies = [
- "ansi_term 0.12.1",
+ "ansi_term",
  "ctor",
  "diff",
  "output_vt100",
 ]
 
-[[package]]
-name = "proc-macro-crate"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fdbd1df62156fbc5945f4762632564d7d038153091c3fcf1067f6aef7cff92"
-dependencies = [
- "thiserror",
- "toml",
-]
-
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -1496,7 +1565,7 @@ checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
 dependencies = [
  "proc-macro-error-attr",
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
  "syn",
  "version_check",
 ]
@@ -1508,31 +1577,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
 dependencies = [
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
  "version_check",
 ]
 
-[[package]]
-name = "proc-macro-hack"
-version = "0.5.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
-
 [[package]]
 name = "proc-macro2"
-version = "1.0.28"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c7ed8b8c7b886ea3ed7dde405212185f423ab44682667c8c6dd14aa1d9f6612"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
 dependencies = [
  "unicode-xid 0.2.2",
 ]
 
-[[package]]
-name = "quick-error"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
-
 [[package]]
 name = "quick-error"
 version = "2.0.1"
@@ -1541,14 +1598,13 @@ checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
 [[package]]
 name = "quickcheck"
-version = "0.9.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44883e74aa97ad63db83c4bf8ca490f02b2fc02f92575e720c8551e843c945f"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
 dependencies = [
- "env_logger 0.7.1",
+ "env_logger 0.8.4",
  "log",
- "rand 0.7.3",
- "rand_core 0.5.1",
+ "rand",
 ]
 
 [[package]]
@@ -1559,46 +1615,13 @@ checksum = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
 
 [[package]]
 name = "quote"
-version = "1.0.9"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d"
 dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "radium"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8"
-
-[[package]]
-name = "rand"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
-dependencies = [
- "cloudabi",
- "fuchsia-cprng",
- "libc",
- "rand_core 0.3.1",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "rand"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
-dependencies = [
- "getrandom 0.1.16",
- "libc",
- "rand_chacha 0.2.2",
- "rand_core 0.5.1",
- "rand_hc 0.2.0",
- "rand_pcg",
-]
-
 [[package]]
 name = "rand"
 version = "0.8.4"
@@ -1606,19 +1629,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
 dependencies = [
  "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.3",
- "rand_hc 0.3.1",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.5.1",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
 ]
 
 [[package]]
@@ -1628,31 +1641,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.6.3",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
-dependencies = [
- "rand_core 0.4.2",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
-
-[[package]]
-name = "rand_core"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
-dependencies = [
- "getrandom 0.1.16",
+ "rand_core",
 ]
 
 [[package]]
@@ -1661,16 +1650,7 @@ version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
 dependencies = [
- "getrandom 0.2.3",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
-dependencies = [
- "rand_core 0.5.1",
+ "getrandom",
 ]
 
 [[package]]
@@ -1679,16 +1659,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
 dependencies = [
- "rand_core 0.6.3",
-]
-
-[[package]]
-name = "rand_pcg"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
-dependencies = [
- "rand_core 0.5.1",
+ "rand_core",
 ]
 
 [[package]]
@@ -1718,9 +1689,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.2.10"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+checksum = "8ae183fc1b06c149f0c1793e1eb447c8b04bfe46d48e9e48bfb8d2d7ed64ecf0"
 dependencies = [
  "bitflags",
 ]
@@ -1747,7 +1718,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
 dependencies = [
  "aho-corasick",
- "memchr 2.4.0",
+ "memchr 2.4.1",
  "regex-syntax",
 ]
 
@@ -1774,9 +1745,24 @@ dependencies = [
 
 [[package]]
 name = "retain_mut"
-version = "0.1.3"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9c17925a9027d298a4603d286befe3f9dc0e8ed02523141914eb628798d6e5b"
+checksum = "53552c6c49e1e13f1a203ef0080ab3bbef0beb570a528993e83df057a9d9bba1"
+
+[[package]]
+name = "ring"
+version = "0.16.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+dependencies = [
+ "cc",
+ "libc",
+ "once_cell",
+ "spin",
+ "untrusted",
+ "web-sys",
+ "winapi 0.3.9",
+]
 
 [[package]]
 name = "rlimit"
@@ -1804,6 +1790,24 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustls"
+version = "0.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b323592e3164322f5b193dc4302e4e36cd8d37158a712d664efae1a5c2791700"
+dependencies = [
+ "log",
+ "ring",
+ "sct",
+ "webpki",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f"
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -1820,10 +1824,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
-name = "selinux"
-version = "0.2.3"
+name = "sct"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cf704a543fe60d898f3253f1cc37655d0f0e9cdb68ef6230557e0e031b80608"
+checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "selinux"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09715d6b4356e916047e61e4dce40a67ac93036851957b91713d3d9c282d1548"
 dependencies = [
  "bitflags",
  "libc",
@@ -1845,68 +1859,49 @@ dependencies = [
  "walkdir",
 ]
 
-[[package]]
-name = "serde"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
-dependencies = [
- "proc-macro2",
- "quote 1.0.9",
- "syn",
-]
-
 [[package]]
 name = "sha1"
-version = "0.6.0"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2579985fda508104f7587689507983eadd6a6e84dd35d6d115361f530916fa0d"
+checksum = "c77f4e7f65455545c2153c1253d25056825e77ee2533f0e41deb65a93a34852f"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "digest",
+]
 
 [[package]]
 name = "sha2"
-version = "0.6.0"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d963c78ce367df26d7ea8b8cc655c651b42e8a1e584e869c1e17dae3ccb116a"
+checksum = "55deaec60f81eefe3cce0dc50bda92d6d8e88f2a27df7c5033b42afeb1ed2676"
 dependencies = [
- "block-buffer",
- "byte-tools",
+ "cfg-if 1.0.0",
+ "cpufeatures",
  "digest",
- "fake-simd",
- "generic-array",
 ]
 
 [[package]]
 name = "sha3"
-version = "0.6.0"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26405905b6a56a94c60109cfda62610507ac14a65be531f5767dec5c5a8dd6a0"
+checksum = "881bf8156c87b6301fc5ca6b27f11eeb2761224c7081e69b409d5a1951a70c86"
 dependencies = [
- "block-buffer",
- "byte-tools",
  "digest",
- "generic-array",
+ "keccak",
 ]
 
 [[package]]
 name = "shlex"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42a568c8f2cd051a4d283bd6eb0343ac214c1b0f1ac19f93e1175b2dee38c73d"
+checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
 
 [[package]]
 name = "signal-hook"
-version = "0.3.9"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "470c5a6397076fae0094aaf06a08e6ba6f37acb77d3b1b91ea92b4d6c8650c39"
+checksum = "647c97df271007dcea485bb74ffdb57f2e683f1306c854f468a0c244badabf2d"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -1919,7 +1914,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "29fd5867f1c4f2c5be079aee7a2adf1152ebb04a4bc4d341f504b7dece607ed4"
 dependencies = [
  "libc",
- "mio 0.7.7",
+ "mio 0.7.14",
  "signal-hook",
 ]
 
@@ -1933,19 +1928,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "smallvec"
-version = "0.6.14"
+name = "siphasher"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97fcaeba89edba30f044a10c6a3cc39df9c3f17d7cd829dd1446cab35f890e0"
-dependencies = [
- "maybe-uninit",
-]
+checksum = "a86232ab60fa71287d7f2ddae4a7073f6b7aac33631c3015abb556f08c6d0a3e"
 
 [[package]]
 name = "smallvec"
-version = "1.6.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
 
 [[package]]
 name = "smawk"
@@ -1955,15 +1947,20 @@ checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
 
 [[package]]
 name = "socket2"
-version = "0.3.19"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e"
+checksum = "0f82496b90c36d70af5fcd482edaa2e0bd16fade569de1330405fecbbdac736b"
 dependencies = [
- "cfg-if 1.0.0",
  "libc",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@@ -1977,49 +1974,56 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 
 [[package]]
-name = "strum"
-version = "0.21.0"
+name = "strsim"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaf86bbcfd1fa9670b7a129f64fc0c9fcbbfe4f1bc4210e9e98fe71ffc12cde2"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "strum"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e96acfc1b70604b8b2f1ffa4c57e59176c7dbb05d556c71ecd2f5498a1dee7f8"
 
 [[package]]
 name = "strum_macros"
-version = "0.21.1"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d06aaeeee809dbc59eb4556183dd927df67db1540de5be8d3ec0b6636358a5ec"
+checksum = "5bb0dc7ee9c15cea6199cde9a127fa16a4c5819af85395457ad72d68edc85a38"
 dependencies = [
  "heck",
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
+ "rustversion",
  "syn",
 ]
 
 [[package]]
-name = "syn"
-version = "1.0.74"
+name = "subtle"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1873d832550d4588c3dbc20f01361ab00bfe741048f71e3fecf145a7cc18b29c"
+checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+
+[[package]]
+name = "syn"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
 dependencies = [
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
  "unicode-xid 0.2.2",
 ]
 
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
 [[package]]
 name = "tempfile"
-version = "3.2.0"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
 dependencies = [
  "cfg-if 1.0.0",
+ "fastrand",
  "libc",
- "rand 0.8.4",
  "redox_syscall",
  "remove_dir_all",
  "winapi 0.3.9",
@@ -2034,16 +2038,6 @@ dependencies = [
  "unicode-width",
 ]
 
-[[package]]
-name = "term_size"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e4129646ca0ed8f45d09b929036bafad5377103edd06e50bf574b353d2b08d9"
-dependencies = [
- "libc",
- "winapi 0.3.9",
-]
-
 [[package]]
 name = "termcolor"
 version = "1.1.2"
@@ -2094,15 +2088,14 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
 dependencies = [
- "term_size",
  "unicode-width",
 ]
 
 [[package]]
 name = "textwrap"
-version = "0.14.2"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
 dependencies = [
  "smawk",
  "terminal_size",
@@ -2112,21 +2105,21 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.26"
+version = "1.0.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93119e4feac1cbe6c798c34d3a53ea0026b0b1de6a120deef895137c0529bfe2"
+checksum = "854babe52e4df1653706b98fcfc05843010039b406875930a70e4d9644e5c417"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.26"
+version = "1.0.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "060d69a0afe7796bf42e9e2ff91f5ee691fb15c53d38b4b62a9a53eb23164745"
+checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
 dependencies = [
  "proc-macro2",
- "quote 1.0.9",
+ "quote 1.0.14",
  "syn",
 ]
 
@@ -2141,19 +2134,31 @@ dependencies = [
 ]
 
 [[package]]
-name = "toml"
-version = "0.5.8"
+name = "tinyvec"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
+checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"
 dependencies = [
- "serde",
+ "tinyvec_macros",
 ]
 
 [[package]]
-name = "typenum"
-version = "1.13.0"
+name = "tinyvec_macros"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "879f6906492a7cd215bfa4cf595b600146ccfac0c79bcbd1f3000162af5e8b06"
+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+
+[[package]]
+name = "typenum"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
 
 [[package]]
 name = "unicode-linebreak"
@@ -2165,16 +2170,25 @@ dependencies = [
 ]
 
 [[package]]
-name = "unicode-segmentation"
-version = "1.8.0"
+name = "unicode-normalization"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
+checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e8820f5d777f6224dc4be3632222971ac30164d4a258d595640799554ebfd99"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
 
 [[package]]
 name = "unicode-xid"
@@ -2190,9 +2204,9 @@ checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
 
 [[package]]
 name = "unindent"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f14ee04d9415b52b3aeab06258a3f07093182b88ba0f9b8d203f211a7a7d41c7"
+checksum = "514672a55d7380da379785a4d70ca8386c8883ff7eaae877be4d2081cebe73d8"
 
 [[package]]
 name = "unix_socket"
@@ -2204,6 +2218,41 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
+[[package]]
+name = "ureq"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9399fa2f927a3d327187cbd201480cee55bee6ac5d3c77dd27f0c6814cff16d5"
+dependencies = [
+ "base64",
+ "chunked_transfer",
+ "flate2",
+ "log",
+ "once_cell",
+ "rustls",
+ "url",
+ "webpki",
+ "webpki-roots",
+]
+
+[[package]]
+name = "url"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "matches",
+ "percent-encoding",
+]
+
 [[package]]
 name = "users"
 version = "0.10.0"
@@ -2228,150 +2277,131 @@ checksum = "7cf7d77f457ef8dfa11e4cd5933c5ddb5dc52a94664071951219a97710f0a32b"
 
 [[package]]
 name = "uu_arch"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "platform-info",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_base32"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_base64"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
  "uu_base32",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_basename"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_basenc"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uu_base32",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_cat"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "atty",
- "clap",
- "nix 0.20.0",
+ "clap 3.1.6",
+ "nix",
  "thiserror",
  "unix_socket",
  "uucore",
- "uucore_procs",
- "winapi-util",
 ]
 
 [[package]]
 name = "uu_chcon"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "fts-sys",
  "libc",
  "selinux",
  "thiserror",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_chgrp"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_chmod"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
- "walkdir",
 ]
 
 [[package]]
 name = "uu_chown"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_chroot"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_cksum"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_comm"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_cp"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "exacl",
  "filetime",
  "ioctl-sys",
  "libc",
- "quick-error 1.2.3",
+ "quick-error",
  "selinux",
  "uucore",
- "uucore_procs",
  "walkdir",
  "winapi 0.3.9",
  "xattr",
@@ -2379,322 +2409,285 @@ dependencies = [
 
 [[package]]
 name = "uu_csplit"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "regex",
  "thiserror",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_cut"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "atty",
  "bstr",
- "clap",
- "memchr 2.4.0",
+ "clap 3.1.6",
+ "memchr 2.4.1",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_date"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "chrono",
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_dd"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "byte-unit",
- "clap",
+ "clap 3.1.6",
  "gcd",
  "libc",
  "signal-hook",
- "tempfile",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_df"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "number_prefix",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_dircolors"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "glob",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_dirname"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_du"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "chrono",
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_echo"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_env"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "rust-ini",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_expand"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "unicode-width",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_expr"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "num-bigint",
  "num-traits",
  "onig",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_factor"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "coz",
  "num-traits",
  "paste",
  "quickcheck",
- "rand 0.7.3",
- "smallvec 0.6.14",
+ "rand",
+ "smallvec",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_false"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_fmt"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "unicode-width",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_fold"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_groups"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_hashsum"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "blake2b_simd",
- "clap",
+ "blake3",
+ "clap 3.1.6",
  "digest",
  "hex",
- "libc",
- "md5",
- "memchr 2.4.0",
+ "md-5",
+ "memchr 2.4.1",
  "regex",
- "regex-syntax",
  "sha1",
  "sha2",
  "sha3",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_head"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "memchr 2.4.0",
+ "clap 3.1.6",
+ "memchr 2.4.1",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_hostid"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_hostname"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "hostname",
- "libc",
  "uucore",
- "uucore_procs",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_id"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "selinux",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_install"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "file_diff",
  "filetime",
  "libc",
- "time",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_join"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
+ "memchr 2.4.1",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_kill"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_link"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_ln"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_logname"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_ls"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "atty",
  "chrono",
- "clap",
- "globset",
+ "clap 3.1.6",
+ "glob",
  "lazy_static",
  "lscolors",
  "number_prefix",
@@ -2704,664 +2697,591 @@ dependencies = [
  "termsize",
  "unicode-width",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_mkdir"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_mkfifo"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_mknod"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_mktemp"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "rand 0.5.6",
+ "clap 3.1.6",
+ "rand",
  "tempfile",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_more"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "atty",
- "clap",
+ "clap 3.1.6",
  "crossterm",
- "nix 0.19.1",
- "redox_syscall",
- "redox_termios",
+ "nix",
  "unicode-segmentation",
  "unicode-width",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_mv"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "fs_extra",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_nice"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
- "nix 0.20.0",
+ "nix",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_nl"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "aho-corasick",
- "clap",
- "libc",
- "memchr 2.4.0",
+ "clap 3.1.6",
  "regex",
- "regex-syntax",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_nohup"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "atty",
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_nproc"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "num_cpus",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_numfmt"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_od"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "byteorder",
- "clap",
+ "clap 3.1.6",
  "half",
- "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_paste"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_pathchk"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_pinky"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_pr"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "chrono",
- "clap",
- "getopts",
- "itertools 0.10.1",
- "quick-error 2.0.1",
+ "clap 3.1.6",
+ "itertools",
+ "quick-error",
  "regex",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_printenv"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_printf"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "itertools 0.8.2",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_ptx"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "aho-corasick",
- "clap",
- "libc",
- "memchr 2.4.0",
+ "clap 3.1.6",
  "regex",
- "regex-syntax",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_pwd"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_readlink"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_realpath"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_relpath"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_rm"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "remove_dir_all",
  "uucore",
- "uucore_procs",
  "walkdir",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_rmdir"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_runcon"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "fts-sys",
+ "clap 3.1.6",
  "libc",
  "selinux",
  "thiserror",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_seq"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "bigdecimal",
+ "clap 3.1.6",
  "num-bigint",
  "num-traits",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_shred"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "libc",
- "rand 0.7.3",
+ "clap 3.1.6",
+ "rand",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_shuf"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "rand 0.5.6",
+ "clap 3.1.6",
+ "rand",
+ "rand_core",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_sleep"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_sort"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "binary-heap-plus",
- "clap",
+ "clap 3.1.6",
  "compare",
  "ctrlc",
  "fnv",
- "itertools 0.10.1",
- "memchr 2.4.0",
+ "itertools",
+ "memchr 2.4.1",
  "ouroboros",
- "rand 0.7.3",
+ "rand",
  "rayon",
  "tempfile",
  "unicode-width",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_split"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
+ "memchr 2.4.1",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_stat"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_stdbuf"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "tempfile",
  "uu_stdbuf_libstdbuf",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "cpp",
  "cpp_build",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_sum"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_sync"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_tac"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "memchr 2.4.0",
+ "clap 3.1.6",
+ "memchr 2.4.1",
  "memmap2",
  "regex",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_tail"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
- "nix 0.20.0",
+ "nix",
  "notify",
- "redox_syscall",
  "uucore",
- "uucore_procs",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_tee"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "retain_mut",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_test"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "redox_syscall",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_timeout"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
- "nix 0.20.0",
+ "nix",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_touch"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "filetime",
  "time",
  "uucore",
- "uucore_procs",
+ "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_tr"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "bit-set",
- "clap",
- "fnv",
+ "clap 3.1.6",
+ "nom",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_true"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_truncate"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_tsort"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_tty"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "atty",
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_uname"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "platform-info",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_unexpand"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "unicode-width",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_uniq"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "strum",
  "strum_macros",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_unlink"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_uptime"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "chrono",
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_users"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_wc"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
  "bytecount",
- "clap",
+ "clap 3.1.6",
  "libc",
- "nix 0.20.0",
+ "nix",
  "unicode-width",
  "utf-8",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_who"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uu_whoami"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "libc",
  "uucore",
- "uucore_procs",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "uu_yes"
-version = "0.0.8"
+version = "0.0.13"
 dependencies = [
- "clap",
- "nix 0.20.0",
+ "clap 3.1.6",
+ "nix",
  "uucore",
- "uucore_procs",
 ]
 
 [[package]]
 name = "uucore"
-version = "0.0.10"
+version = "0.0.13"
 dependencies = [
- "clap",
+ "clap 3.1.6",
  "data-encoding",
  "data-encoding-macro",
  "dns-lookup",
  "dunce",
- "getopts",
+ "itertools",
  "lazy_static",
  "libc",
- "nix 0.20.0",
+ "nix",
  "once_cell",
- "termion",
+ "os_display",
  "thiserror",
  "time",
+ "uucore_procs",
  "walkdir",
  "wild",
  "winapi 0.3.9",
+ "winapi-util",
  "z85",
 ]
 
 [[package]]
 name = "uucore_procs"
-version = "0.0.7"
+version = "0.0.13"
 dependencies = [
  "proc-macro2",
- "quote 1.0.9",
- "syn",
+ "quote 1.0.14",
 ]
 
 [[package]]
@@ -3378,9 +3298,9 @@ checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
 
 [[package]]
 name = "version_check"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "walkdir"
@@ -3393,12 +3313,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
 [[package]]
 name = "wasi"
 version = "0.10.2+wasi-snapshot-preview1"
@@ -3412,11 +3326,96 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
-name = "which"
-version = "3.1.1"
+name = "wasm-bindgen"
+version = "0.2.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d011071ae14a2f6671d0b74080ae0cd8ebf3a6f8c9589a2cd45f23126fe29724"
+checksum = "25f1af7423d8588a3d840681122e72e6a24ddbcb3f0ec385cac0d12d24256c06"
 dependencies = [
+ "cfg-if 1.0.0",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b21c0df030f5a177f3cba22e9bc4322695ec43e7257d865302900290bcdedca"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote 1.0.14",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4203d69e40a52ee523b2529a773d5ffc1dc0071801c87b3d270b471b80ed01"
+dependencies = [
+ "quote 1.0.14",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa8a30d46208db204854cadbb5d4baf5fcf8071ba5bf48190c3e59937962ebc"
+dependencies = [
+ "proc-macro2",
+ "quote 1.0.14",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d958d035c4438e28c70e4321a2911302f10135ce78a9c7834c0cab4123d06a2"
+
+[[package]]
+name = "web-sys"
+version = "0.3.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c060b319f29dd25724f09a2ba1418f142f539b2be99fbf4d2d5a8f7330afb8eb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.22.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "552ceb903e957524388c4d3475725ff2c8b7960922063af6ce53c9a43da07449"
+dependencies = [
+ "webpki",
+]
+
+[[package]]
+name = "which"
+version = "4.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea187a8ef279bc014ec368c27a920da2024d2a711109bfbe3440585d5cf27ad9"
+dependencies = [
+ "either",
+ "lazy_static",
  "libc",
 ]
 
@@ -3473,10 +3472,47 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
-name = "wyz"
-version = "0.2.0"
+name = "windows-sys"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85e60b0d1b5f99db2556934e21937020776a5d31520bf169e851ac44e6420214"
+checksum = "3df6e476185f92a12c072be4a189a0210dcdcf512a1891d6dff9edb874deadc6"
+dependencies = [
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316"
 
 [[package]]
 name = "xattr"
@@ -3489,6 +3525,18 @@ dependencies = [
 
 [[package]]
 name = "z85"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ac8b56e4f9906a4ef5412875e9ce448364023335cec645fd457ecf51d4f2781"
+checksum = "af896e93db81340b74b65f74276a99b210c086f3d34ed0abf433182a462af856"
+
+[[package]]
+name = "zip"
+version = "0.5.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93ab48844d61251bb3835145c521d88aa4031d7139e8485990f60ca911fa0815"
+dependencies = [
+ "byteorder",
+ "crc32fast",
+ "flate2",
+ "thiserror",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 9ecea79c2..377f466eb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,10 +5,11 @@
 
 [package]
 name = "coreutils"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust"
+default-run = "coreutils"
 
 homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils"
@@ -244,113 +245,117 @@ test = [ "uu_test" ]
 [workspace]
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+clap_complete = "3.1"
+phf = "0.10.1"
 lazy_static = { version="1.3" }
-textwrap = { version="0.14", features=["terminal_size"] }
-uucore = { version=">=0.0.10", package="uucore", path="src/uucore" }
-selinux = { version="0.2.3", optional = true }
+textwrap = { version="0.15", features=["terminal_size"] }
+uucore = { version=">=0.0.11", package="uucore", path="src/uucore" }
+selinux = { version="0.2", optional = true }
+ureq = "2.4.0"
+zip = { version = "0.5.13", default_features=false, features=["deflate"] }
 # * uutils
-uu_test  = { optional=true, version="0.0.8", package="uu_test", path="src/uu/test" }
+uu_test  = { optional=true, version="0.0.13", package="uu_test", path="src/uu/test" }
 #
-arch     = { optional=true, version="0.0.8", package="uu_arch", path="src/uu/arch" }
-base32   = { optional=true, version="0.0.8", package="uu_base32", path="src/uu/base32" }
-base64   = { optional=true, version="0.0.8", package="uu_base64", path="src/uu/base64" }
-basename = { optional=true, version="0.0.8", package="uu_basename", path="src/uu/basename" }
-basenc   = { optional=true, version="0.0.8", package="uu_basenc", path="src/uu/basenc" }
-cat      = { optional=true, version="0.0.8", package="uu_cat", path="src/uu/cat" }
-chcon    = { optional=true, version="0.0.8", package="uu_chcon", path="src/uu/chcon" }
-chgrp    = { optional=true, version="0.0.8", package="uu_chgrp", path="src/uu/chgrp" }
-chmod    = { optional=true, version="0.0.8", package="uu_chmod", path="src/uu/chmod" }
-chown    = { optional=true, version="0.0.8", package="uu_chown", path="src/uu/chown" }
-chroot   = { optional=true, version="0.0.8", package="uu_chroot", path="src/uu/chroot" }
-cksum    = { optional=true, version="0.0.8", package="uu_cksum", path="src/uu/cksum" }
-comm     = { optional=true, version="0.0.8", package="uu_comm", path="src/uu/comm" }
-cp       = { optional=true, version="0.0.8", package="uu_cp", path="src/uu/cp" }
-csplit   = { optional=true, version="0.0.8", package="uu_csplit", path="src/uu/csplit" }
-cut      = { optional=true, version="0.0.8", package="uu_cut", path="src/uu/cut" }
-date     = { optional=true, version="0.0.8", package="uu_date", path="src/uu/date" }
-dd       = { optional=true, version="0.0.8", package="uu_dd", path="src/uu/dd" }
-df       = { optional=true, version="0.0.8", package="uu_df", path="src/uu/df" }
-dircolors= { optional=true, version="0.0.8", package="uu_dircolors", path="src/uu/dircolors" }
-dirname  = { optional=true, version="0.0.8", package="uu_dirname", path="src/uu/dirname" }
-du       = { optional=true, version="0.0.8", package="uu_du", path="src/uu/du" }
-echo     = { optional=true, version="0.0.8", package="uu_echo", path="src/uu/echo" }
-env      = { optional=true, version="0.0.8", package="uu_env", path="src/uu/env" }
-expand   = { optional=true, version="0.0.8", package="uu_expand", path="src/uu/expand" }
-expr     = { optional=true, version="0.0.8", package="uu_expr", path="src/uu/expr" }
-factor   = { optional=true, version="0.0.8", package="uu_factor", path="src/uu/factor" }
-false    = { optional=true, version="0.0.8", package="uu_false", path="src/uu/false" }
-fmt      = { optional=true, version="0.0.8", package="uu_fmt", path="src/uu/fmt" }
-fold     = { optional=true, version="0.0.8", package="uu_fold", path="src/uu/fold" }
-groups   = { optional=true, version="0.0.8", package="uu_groups", path="src/uu/groups" }
-hashsum  = { optional=true, version="0.0.8", package="uu_hashsum", path="src/uu/hashsum" }
-head     = { optional=true, version="0.0.8", package="uu_head", path="src/uu/head" }
-hostid   = { optional=true, version="0.0.8", package="uu_hostid", path="src/uu/hostid" }
-hostname = { optional=true, version="0.0.8", package="uu_hostname", path="src/uu/hostname" }
-id       = { optional=true, version="0.0.8", package="uu_id", path="src/uu/id" }
-install  = { optional=true, version="0.0.8", package="uu_install", path="src/uu/install" }
-join     = { optional=true, version="0.0.8", package="uu_join", path="src/uu/join" }
-kill     = { optional=true, version="0.0.8", package="uu_kill", path="src/uu/kill" }
-link     = { optional=true, version="0.0.8", package="uu_link", path="src/uu/link" }
-ln       = { optional=true, version="0.0.8", package="uu_ln", path="src/uu/ln" }
-ls       = { optional=true, version="0.0.8", package="uu_ls", path="src/uu/ls" }
-logname  = { optional=true, version="0.0.8", package="uu_logname", path="src/uu/logname" }
-mkdir    = { optional=true, version="0.0.8", package="uu_mkdir", path="src/uu/mkdir" }
-mkfifo   = { optional=true, version="0.0.8", package="uu_mkfifo", path="src/uu/mkfifo" }
-mknod    = { optional=true, version="0.0.8", package="uu_mknod", path="src/uu/mknod" }
-mktemp   = { optional=true, version="0.0.8", package="uu_mktemp", path="src/uu/mktemp" }
-more     = { optional=true, version="0.0.8", package="uu_more", path="src/uu/more" }
-mv       = { optional=true, version="0.0.8", package="uu_mv", path="src/uu/mv" }
-nice     = { optional=true, version="0.0.8", package="uu_nice", path="src/uu/nice" }
-nl       = { optional=true, version="0.0.8", package="uu_nl", path="src/uu/nl" }
-nohup    = { optional=true, version="0.0.8", package="uu_nohup", path="src/uu/nohup" }
-nproc    = { optional=true, version="0.0.8", package="uu_nproc", path="src/uu/nproc" }
-numfmt   = { optional=true, version="0.0.8", package="uu_numfmt", path="src/uu/numfmt" }
-od       = { optional=true, version="0.0.8", package="uu_od", path="src/uu/od" }
-paste    = { optional=true, version="0.0.8", package="uu_paste", path="src/uu/paste" }
-pathchk  = { optional=true, version="0.0.8", package="uu_pathchk", path="src/uu/pathchk" }
-pinky    = { optional=true, version="0.0.8", package="uu_pinky", path="src/uu/pinky" }
-pr       = { optional=true, version="0.0.8", package="uu_pr", path="src/uu/pr" }
-printenv = { optional=true, version="0.0.8", package="uu_printenv", path="src/uu/printenv" }
-printf   = { optional=true, version="0.0.8", package="uu_printf", path="src/uu/printf" }
-ptx      = { optional=true, version="0.0.8", package="uu_ptx", path="src/uu/ptx" }
-pwd      = { optional=true, version="0.0.8", package="uu_pwd", path="src/uu/pwd" }
-readlink = { optional=true, version="0.0.8", package="uu_readlink", path="src/uu/readlink" }
-realpath = { optional=true, version="0.0.8", package="uu_realpath", path="src/uu/realpath" }
-relpath  = { optional=true, version="0.0.8", package="uu_relpath", path="src/uu/relpath" }
-rm       = { optional=true, version="0.0.8", package="uu_rm", path="src/uu/rm" }
-rmdir    = { optional=true, version="0.0.8", package="uu_rmdir", path="src/uu/rmdir" }
-runcon   = { optional=true, version="0.0.8", package="uu_runcon", path="src/uu/runcon" }
-seq      = { optional=true, version="0.0.8", package="uu_seq", path="src/uu/seq" }
-shred    = { optional=true, version="0.0.8", package="uu_shred", path="src/uu/shred" }
-shuf     = { optional=true, version="0.0.8", package="uu_shuf", path="src/uu/shuf" }
-sleep    = { optional=true, version="0.0.8", package="uu_sleep", path="src/uu/sleep" }
-sort     = { optional=true, version="0.0.8", package="uu_sort", path="src/uu/sort" }
-split    = { optional=true, version="0.0.8", package="uu_split", path="src/uu/split" }
-stat     = { optional=true, version="0.0.8", package="uu_stat", path="src/uu/stat" }
-stdbuf   = { optional=true, version="0.0.8", package="uu_stdbuf", path="src/uu/stdbuf" }
-sum      = { optional=true, version="0.0.8", package="uu_sum", path="src/uu/sum" }
-sync     = { optional=true, version="0.0.8", package="uu_sync", path="src/uu/sync" }
-tac      = { optional=true, version="0.0.8", package="uu_tac", path="src/uu/tac" }
-tail     = { optional=true, version="0.0.8", package="uu_tail", path="src/uu/tail" }
-tee      = { optional=true, version="0.0.8", package="uu_tee", path="src/uu/tee" }
-timeout  = { optional=true, version="0.0.8", package="uu_timeout", path="src/uu/timeout" }
-touch    = { optional=true, version="0.0.8", package="uu_touch", path="src/uu/touch" }
-tr       = { optional=true, version="0.0.8", package="uu_tr", path="src/uu/tr" }
-true     = { optional=true, version="0.0.8", package="uu_true", path="src/uu/true" }
-truncate = { optional=true, version="0.0.8", package="uu_truncate", path="src/uu/truncate" }
-tsort    = { optional=true, version="0.0.8", package="uu_tsort", path="src/uu/tsort" }
-tty      = { optional=true, version="0.0.8", package="uu_tty", path="src/uu/tty" }
-uname    = { optional=true, version="0.0.8", package="uu_uname", path="src/uu/uname" }
-unexpand = { optional=true, version="0.0.8", package="uu_unexpand", path="src/uu/unexpand" }
-uniq     = { optional=true, version="0.0.8", package="uu_uniq", path="src/uu/uniq" }
-unlink   = { optional=true, version="0.0.8", package="uu_unlink", path="src/uu/unlink" }
-uptime   = { optional=true, version="0.0.8", package="uu_uptime", path="src/uu/uptime" }
-users    = { optional=true, version="0.0.8", package="uu_users", path="src/uu/users" }
-wc       = { optional=true, version="0.0.8", package="uu_wc", path="src/uu/wc" }
-who      = { optional=true, version="0.0.8", package="uu_who", path="src/uu/who" }
-whoami   = { optional=true, version="0.0.8", package="uu_whoami", path="src/uu/whoami" }
-yes      = { optional=true, version="0.0.8", package="uu_yes", path="src/uu/yes" }
+arch     = { optional=true, version="0.0.13", package="uu_arch", path="src/uu/arch" }
+base32   = { optional=true, version="0.0.13", package="uu_base32", path="src/uu/base32" }
+base64   = { optional=true, version="0.0.13", package="uu_base64", path="src/uu/base64" }
+basename = { optional=true, version="0.0.13", package="uu_basename", path="src/uu/basename" }
+basenc   = { optional=true, version="0.0.13", package="uu_basenc", path="src/uu/basenc" }
+cat      = { optional=true, version="0.0.13", package="uu_cat", path="src/uu/cat" }
+chcon    = { optional=true, version="0.0.13", package="uu_chcon", path="src/uu/chcon" }
+chgrp    = { optional=true, version="0.0.13", package="uu_chgrp", path="src/uu/chgrp" }
+chmod    = { optional=true, version="0.0.13", package="uu_chmod", path="src/uu/chmod" }
+chown    = { optional=true, version="0.0.13", package="uu_chown", path="src/uu/chown" }
+chroot   = { optional=true, version="0.0.13", package="uu_chroot", path="src/uu/chroot" }
+cksum    = { optional=true, version="0.0.13", package="uu_cksum", path="src/uu/cksum" }
+comm     = { optional=true, version="0.0.13", package="uu_comm", path="src/uu/comm" }
+cp       = { optional=true, version="0.0.13", package="uu_cp", path="src/uu/cp" }
+csplit   = { optional=true, version="0.0.13", package="uu_csplit", path="src/uu/csplit" }
+cut      = { optional=true, version="0.0.13", package="uu_cut", path="src/uu/cut" }
+date     = { optional=true, version="0.0.13", package="uu_date", path="src/uu/date" }
+dd       = { optional=true, version="0.0.13", package="uu_dd", path="src/uu/dd" }
+df       = { optional=true, version="0.0.13", package="uu_df", path="src/uu/df" }
+dircolors= { optional=true, version="0.0.13", package="uu_dircolors", path="src/uu/dircolors" }
+dirname  = { optional=true, version="0.0.13", package="uu_dirname", path="src/uu/dirname" }
+du       = { optional=true, version="0.0.13", package="uu_du", path="src/uu/du" }
+echo     = { optional=true, version="0.0.13", package="uu_echo", path="src/uu/echo" }
+env      = { optional=true, version="0.0.13", package="uu_env", path="src/uu/env" }
+expand   = { optional=true, version="0.0.13", package="uu_expand", path="src/uu/expand" }
+expr     = { optional=true, version="0.0.13", package="uu_expr", path="src/uu/expr" }
+factor   = { optional=true, version="0.0.13", package="uu_factor", path="src/uu/factor" }
+false    = { optional=true, version="0.0.13", package="uu_false", path="src/uu/false" }
+fmt      = { optional=true, version="0.0.13", package="uu_fmt", path="src/uu/fmt" }
+fold     = { optional=true, version="0.0.13", package="uu_fold", path="src/uu/fold" }
+groups   = { optional=true, version="0.0.13", package="uu_groups", path="src/uu/groups" }
+hashsum  = { optional=true, version="0.0.13", package="uu_hashsum", path="src/uu/hashsum" }
+head     = { optional=true, version="0.0.13", package="uu_head", path="src/uu/head" }
+hostid   = { optional=true, version="0.0.13", package="uu_hostid", path="src/uu/hostid" }
+hostname = { optional=true, version="0.0.13", package="uu_hostname", path="src/uu/hostname" }
+id       = { optional=true, version="0.0.13", package="uu_id", path="src/uu/id" }
+install  = { optional=true, version="0.0.13", package="uu_install", path="src/uu/install" }
+join     = { optional=true, version="0.0.13", package="uu_join", path="src/uu/join" }
+kill     = { optional=true, version="0.0.13", package="uu_kill", path="src/uu/kill" }
+link     = { optional=true, version="0.0.13", package="uu_link", path="src/uu/link" }
+ln       = { optional=true, version="0.0.13", package="uu_ln", path="src/uu/ln" }
+ls       = { optional=true, version="0.0.13", package="uu_ls", path="src/uu/ls" }
+logname  = { optional=true, version="0.0.13", package="uu_logname", path="src/uu/logname" }
+mkdir    = { optional=true, version="0.0.13", package="uu_mkdir", path="src/uu/mkdir" }
+mkfifo   = { optional=true, version="0.0.13", package="uu_mkfifo", path="src/uu/mkfifo" }
+mknod    = { optional=true, version="0.0.13", package="uu_mknod", path="src/uu/mknod" }
+mktemp   = { optional=true, version="0.0.13", package="uu_mktemp", path="src/uu/mktemp" }
+more     = { optional=true, version="0.0.13", package="uu_more", path="src/uu/more" }
+mv       = { optional=true, version="0.0.13", package="uu_mv", path="src/uu/mv" }
+nice     = { optional=true, version="0.0.13", package="uu_nice", path="src/uu/nice" }
+nl       = { optional=true, version="0.0.13", package="uu_nl", path="src/uu/nl" }
+nohup    = { optional=true, version="0.0.13", package="uu_nohup", path="src/uu/nohup" }
+nproc    = { optional=true, version="0.0.13", package="uu_nproc", path="src/uu/nproc" }
+numfmt   = { optional=true, version="0.0.13", package="uu_numfmt", path="src/uu/numfmt" }
+od       = { optional=true, version="0.0.13", package="uu_od", path="src/uu/od" }
+paste    = { optional=true, version="0.0.13", package="uu_paste", path="src/uu/paste" }
+pathchk  = { optional=true, version="0.0.13", package="uu_pathchk", path="src/uu/pathchk" }
+pinky    = { optional=true, version="0.0.13", package="uu_pinky", path="src/uu/pinky" }
+pr       = { optional=true, version="0.0.13", package="uu_pr", path="src/uu/pr" }
+printenv = { optional=true, version="0.0.13", package="uu_printenv", path="src/uu/printenv" }
+printf   = { optional=true, version="0.0.13", package="uu_printf", path="src/uu/printf" }
+ptx      = { optional=true, version="0.0.13", package="uu_ptx", path="src/uu/ptx" }
+pwd      = { optional=true, version="0.0.13", package="uu_pwd", path="src/uu/pwd" }
+readlink = { optional=true, version="0.0.13", package="uu_readlink", path="src/uu/readlink" }
+realpath = { optional=true, version="0.0.13", package="uu_realpath", path="src/uu/realpath" }
+relpath  = { optional=true, version="0.0.13", package="uu_relpath", path="src/uu/relpath" }
+rm       = { optional=true, version="0.0.13", package="uu_rm", path="src/uu/rm" }
+rmdir    = { optional=true, version="0.0.13", package="uu_rmdir", path="src/uu/rmdir" }
+runcon   = { optional=true, version="0.0.13", package="uu_runcon", path="src/uu/runcon" }
+seq      = { optional=true, version="0.0.13", package="uu_seq", path="src/uu/seq" }
+shred    = { optional=true, version="0.0.13", package="uu_shred", path="src/uu/shred" }
+shuf     = { optional=true, version="0.0.13", package="uu_shuf", path="src/uu/shuf" }
+sleep    = { optional=true, version="0.0.13", package="uu_sleep", path="src/uu/sleep" }
+sort     = { optional=true, version="0.0.13", package="uu_sort", path="src/uu/sort" }
+split    = { optional=true, version="0.0.13", package="uu_split", path="src/uu/split" }
+stat     = { optional=true, version="0.0.13", package="uu_stat", path="src/uu/stat" }
+stdbuf   = { optional=true, version="0.0.13", package="uu_stdbuf", path="src/uu/stdbuf" }
+sum      = { optional=true, version="0.0.13", package="uu_sum", path="src/uu/sum" }
+sync     = { optional=true, version="0.0.13", package="uu_sync", path="src/uu/sync" }
+tac      = { optional=true, version="0.0.13", package="uu_tac", path="src/uu/tac" }
+tail     = { optional=true, version="0.0.13", package="uu_tail", path="src/uu/tail" }
+tee      = { optional=true, version="0.0.13", package="uu_tee", path="src/uu/tee" }
+timeout  = { optional=true, version="0.0.13", package="uu_timeout", path="src/uu/timeout" }
+touch    = { optional=true, version="0.0.13", package="uu_touch", path="src/uu/touch" }
+tr       = { optional=true, version="0.0.13", package="uu_tr", path="src/uu/tr" }
+true     = { optional=true, version="0.0.13", package="uu_true", path="src/uu/true" }
+truncate = { optional=true, version="0.0.13", package="uu_truncate", path="src/uu/truncate" }
+tsort    = { optional=true, version="0.0.13", package="uu_tsort", path="src/uu/tsort" }
+tty      = { optional=true, version="0.0.13", package="uu_tty", path="src/uu/tty" }
+uname    = { optional=true, version="0.0.13", package="uu_uname", path="src/uu/uname" }
+unexpand = { optional=true, version="0.0.13", package="uu_unexpand", path="src/uu/unexpand" }
+uniq     = { optional=true, version="0.0.13", package="uu_uniq", path="src/uu/uniq" }
+unlink   = { optional=true, version="0.0.13", package="uu_unlink", path="src/uu/unlink" }
+uptime   = { optional=true, version="0.0.13", package="uu_uptime", path="src/uu/uptime" }
+users    = { optional=true, version="0.0.13", package="uu_users", path="src/uu/users" }
+wc       = { optional=true, version="0.0.13", package="uu_wc", path="src/uu/wc" }
+who      = { optional=true, version="0.0.13", package="uu_who", path="src/uu/who" }
+whoami   = { optional=true, version="0.0.13", package="uu_whoami", path="src/uu/whoami" }
+yes      = { optional=true, version="0.0.13", 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" }
@@ -361,32 +366,38 @@ yes      = { optional=true, version="0.0.8", package="uu_yes", path="src/uu/yes"
 #pin_cc = { version="1.0.61, < 1.0.62", package="cc" } ## cc v1.0.62 has compiler errors for MinRustV v1.32.0, requires 1.34 (for `std::str::split_ascii_whitespace()`)
 
 [dev-dependencies]
-chrono = "0.4.11"
+chrono = "^0.4.11"
 conv = "0.3"
 filetime = "0.2"
 glob = "0.3.0"
 libc = "0.2"
-pretty_assertions = "0.7.2"
-rand = "0.7"
+pretty_assertions = "1"
+rand = "0.8"
 regex = "1.0"
-sha1 = { version="0.6", features=["std"] }
-tempfile = "3.2.0"
+sha1 = { version="0.10", features=["std"] }
+tempfile = "3"
 time = "0.1"
 unindent = "0.1"
-uucore = { version=">=0.0.10", package="uucore", path="src/uucore", features=["entries", "process"] }
+uucore = { version=">=0.0.11", package="uucore", path="src/uucore", features=["entries", "process"] }
 walkdir = "2.2"
 atty = "0.2"
+hex-literal = "0.3.1"
 
 [target.'cfg(target_os = "linux")'.dev-dependencies]
 rlimit = "0.4.0"
 
 [target.'cfg(unix)'.dev-dependencies]
-nix = "0.20.0"
-
+nix = "0.23.1"
 rust-users = { version="0.10", package="users" }
 unix_socket = "0.5.0"
 
+[build-dependencies]
+phf_codegen = "0.10.0"
 
 [[bin]]
 name = "coreutils"
 path = "src/bin/coreutils.rs"
+
+[[bin]]
+name = "uudoc"
+path = "src/bin/uudoc.rs"
diff --git a/DEVELOPER_INSTRUCTIONS.md b/DEVELOPER_INSTRUCTIONS.md
index 027d4dca1..c007fba7e 100644
--- a/DEVELOPER_INSTRUCTIONS.md
+++ b/DEVELOPER_INSTRUCTIONS.md
@@ -21,7 +21,7 @@ Running GNU tests
 At the end you should have uutils, gnu and gnulib checked out next to each other.
 
 - Run `cd uutils && ./util/build-gnu.sh && cd ..` to get everything ready (this may take a while)
-- Finally, you can run `tests with bash uutils/util/run-gnu-test.sh <test>`. Instead of `<test>` insert the test you want to run, e.g. `tests/misc/wc-proc`.
+- Finally, you can run tests with `bash uutils/util/run-gnu-test.sh <test>`. Instead of `<test>` insert the test you want to run, e.g. `tests/misc/wc-proc.sh`.
 
 
 Code Coverage Report Generation
@@ -33,7 +33,7 @@ Code coverage report can be generated using [grcov](https://github.com/mozilla/g
 
 ### Using Nightly Rust
 
-To generate [gcov-based](https://github.com/mozilla/grcov#example-how-to-generate-gcda-files-for-cc) coverage report
+To generate [gcov-based](https://github.com/mozilla/grcov#example-how-to-generate-gcda-files-for-a-rust-project) coverage report
 
 ```bash
 $ export CARGO_INCREMENTAL=0
diff --git a/GNUmakefile b/GNUmakefile
index 367568ca8..281952736 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -26,11 +26,6 @@ BINDIR ?= /bin
 MANDIR ?= /man/man1
 
 INSTALLDIR_BIN=$(DESTDIR)$(PREFIX)$(BINDIR)
-INSTALLDIR_MAN=$(DESTDIR)$(PREFIX)/share/$(MANDIR)
-$(shell test -d $(INSTALLDIR_MAN))
-ifneq ($(.SHELLSTATUS),0)
-override INSTALLDIR_MAN=$(DESTDIR)$(PREFIX)$(MANDIR)
-endif
 
 #prefix to apply to coreutils binary and all tool binaries
 PROG_PREFIX ?=
@@ -47,18 +42,19 @@ BUSYBOX_VER  := 1.32.1
 BUSYBOX_SRC  := $(BUSYBOX_ROOT)/busybox-$(BUSYBOX_VER)
 
 ifeq ($(SELINUX_ENABLED),)
-    SELINUX_ENABLED := 0
-    ifneq ($(OS),Windows_NT)
-        ifeq ($(shell /sbin/selinuxenabled 2>/dev/null ; echo $$?),0)
-            SELINUX_ENABLED := 1
-        endif
-    endif
+	SELINUX_ENABLED := 0
+	ifneq ($(OS),Windows_NT)
+		ifeq ($(shell /sbin/selinuxenabled 2>/dev/null ; echo $$?),0)
+			SELINUX_ENABLED := 1
+		endif
+	endif
 endif
 
 # Possible programs
 PROGS       := \
 	base32 \
 	base64 \
+	basenc \
 	basename \
 	cat \
 	cksum \
@@ -67,6 +63,7 @@ PROGS       := \
 	csplit \
 	cut \
 	date \
+	dd \
 	df \
 	dircolors \
 	dirname \
@@ -161,11 +158,11 @@ SELINUX_PROGS := \
 	runcon
 
 ifneq ($(OS),Windows_NT)
-	PROGS    := $(PROGS) $(UNIX_PROGS)
+	PROGS := $(PROGS) $(UNIX_PROGS)
 endif
 
 ifeq ($(SELINUX_ENABLED),1)
-    PROGS := $(PROGS) $(SELINUX_PROGS)
+	PROGS := $(PROGS) $(SELINUX_PROGS)
 endif
 
 UTILS ?= $(PROGS)
@@ -279,10 +276,7 @@ endif
 build-coreutils:
 	${CARGO} build ${CARGOFLAGS} --features "${EXES}" ${PROFILE_CMD} --no-default-features
 
-build-manpages:
-	cd $(DOCSDIR) && $(MAKE) man
-
-build: build-coreutils build-pkgs build-manpages
+build: build-coreutils build-pkgs
 
 $(foreach test,$(filter-out $(SKIP_UTILS),$(PROGS)),$(eval $(call TEST_BUSYBOX,$(test))))
 
@@ -316,7 +310,7 @@ busytest: $(BUILDDIR)/busybox $(addprefix test_busybox_,$(filter-out $(SKIP_UTIL
 endif
 
 clean:
-	$(RM) $(BUILDDIR)
+	cargo clean
 	cd $(DOCSDIR) && $(MAKE) clean
 
 distclean: clean
@@ -324,20 +318,16 @@ distclean: clean
 
 install: build
 	mkdir -p $(INSTALLDIR_BIN)
-	mkdir -p $(INSTALLDIR_MAN)
 ifeq (${MULTICALL}, y)
 	$(INSTALL) $(BUILDDIR)/coreutils $(INSTALLDIR_BIN)/$(PROG_PREFIX)coreutils
 	cd $(INSTALLDIR_BIN) && $(foreach prog, $(filter-out coreutils, $(INSTALLEES)), \
 		ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)$(prog) &&) :
 	$(if $(findstring test,$(INSTALLEES)), cd $(INSTALLDIR_BIN) && ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)[)
-	cat $(DOCSDIR)/_build/man/coreutils.1 | gzip > $(INSTALLDIR_MAN)/$(PROG_PREFIX)coreutils.1.gz
 else
 	$(foreach prog, $(INSTALLEES), \
 		$(INSTALL) $(BUILDDIR)/$(prog) $(INSTALLDIR_BIN)/$(PROG_PREFIX)$(prog);)
 	$(if $(findstring test,$(INSTALLEES)), $(INSTALL) $(BUILDDIR)/test $(INSTALLDIR_BIN)/$(PROG_PREFIX)[)
 endif
-	$(foreach man, $(filter $(INSTALLEES), $(basename $(notdir $(wildcard $(DOCSDIR)/_build/man/*)))), \
-		cat $(DOCSDIR)/_build/man/$(man).1 | gzip > $(INSTALLDIR_MAN)/$(PROG_PREFIX)$(man).1.gz &&) :
 	mkdir -p $(DESTDIR)$(PREFIX)/share/zsh/site-functions
 	mkdir -p $(DESTDIR)$(PREFIX)/share/bash-completion/completions
 	mkdir -p $(DESTDIR)$(PREFIX)/share/fish/vendor_completions.d
@@ -351,12 +341,10 @@ uninstall:
 ifeq (${MULTICALL}, y)
 	rm -f $(addprefix $(INSTALLDIR_BIN)/,$(PROG_PREFIX)coreutils)
 endif
-	rm -f $(addprefix $(INSTALLDIR_MAN)/,$(PROG_PREFIX)coreutils.1.gz)
 	rm -f $(addprefix $(INSTALLDIR_BIN)/$(PROG_PREFIX),$(PROGS))
 	rm -f $(INSTALLDIR_BIN)/$(PROG_PREFIX)[
 	rm -f $(addprefix $(DESTDIR)$(PREFIX)/share/zsh/site-functions/_$(PROG_PREFIX),$(PROGS))
 	rm -f $(addprefix $(DESTDIR)$(PREFIX)/share/bash-completion/completions/$(PROG_PREFIX),$(PROGS))
 	rm -f $(addprefix $(DESTDIR)$(PREFIX)/share/fish/vendor_completions.d/$(PROG_PREFIX),$(addsuffix .fish,$(PROGS)))
-	rm -f $(addprefix $(INSTALLDIR_MAN)/$(PROG_PREFIX),$(addsuffix .1.gz,$(PROGS)))
 
-.PHONY: all build build-coreutils build-pkgs build-docs test distclean clean busytest install uninstall
+.PHONY: all build build-coreutils build-pkgs test distclean clean busytest install uninstall
diff --git a/LICENSE b/LICENSE
index 0177c4ab7..49fdbd4cf 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) Jordi Boggiano
+Copyright (c) Jordi Boggiano and many others
 
 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 7e420bb33..0683e42f8 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 [![Crates.io](https://img.shields.io/crates/v/coreutils.svg)](https://crates.io/crates/coreutils)
 [![Discord](https://img.shields.io/badge/discord-join-7289DA.svg?logo=discord&longCache=true&style=flat)](https://discord.gg/wQVJbvJ)
-[![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/coreutils/blob/master/LICENSE)
+[![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/uutils/coreutils/blob/main/LICENSE)
 [![LOC](https://tokei.rs/b1/github/uutils/coreutils?category=code)](https://github.com/Aaronepower/tokei)
 [![dependency status](https://deps.rs/repo/github/uutils/coreutils/status.svg)](https://deps.rs/repo/github/uutils/coreutils)
 
@@ -15,35 +15,46 @@
 <!-- spell-checker:ignore markdownlint ; (options) DESTDIR RUNTEST UTILNAME -->
 
 uutils is an attempt at writing universal (as in cross-platform) CLI
-utilities in [Rust](http://www.rust-lang.org). This repository is intended to
-aggregate GNU coreutils rewrites.
+utilities in [Rust](http://www.rust-lang.org).
+
+To install it:
+
+```
+$ cargo install coreutils
+$ ~/.cargo/bin/coreutils
+```
 
 ## Why?
 
-Many GNU, Linux and other utilities are useful, and obviously
-[some](http://gnuwin32.sourceforge.net) [effort](http://unxutils.sourceforge.net)
-has been spent in the past to port them to Windows. However, those projects
-are written in platform-specific C, a language considered unsafe compared to Rust, and
-have other issues.
+uutils aims to work on as many platforms as possible, to be able to use the
+same utils on Linux, Mac, Windows and other platforms. This ensures, for
+example, that scripts can be easily transferred between platforms. Rust was
+chosen not only because it is fast and safe, but is also excellent for
+writing cross-platform code.
 
-Rust provides a good, platform-agnostic way of writing systems utilities that are easy
-to compile anywhere, and this is as good a way as any to try and learn it.
+## Documentation
+uutils has both user and developer documentation available:
 
+- [User Manual](https://uutils.github.io/coreutils-docs/user/)
+- [Developer Documentation](https://uutils.github.io/coreutils-docs/dev/coreutils/)
+
+Both can also be generated locally, the instructions for that can be found in the
+[coreutils docs](https://github.com/uutils/coreutils-docs) repository.
+
+<!-- ANCHOR: installation (this mark is needed for mdbook) -->
 ## Requirements
 
 * Rust (`cargo`, `rustc`)
-* GNU Make (required to build documentation)
-* [Sphinx](http://www.sphinx-doc.org/) (for documentation)
-* gzip (for installing documentation)
+* GNU Make (optional)
 
 ### Rust Version
 
 uutils follows Rust's release channels and is tested against stable, beta and nightly.
-The current oldest supported version of the Rust compiler is `1.47`.
+The current oldest supported version of the Rust compiler is `1.56`.
 
 On both Windows and Redox, only the nightly version is tested currently.
 
-## Build Instructions
+## Building
 
 There are currently two methods to build the uutils binaries: either Cargo
 or GNU Make.
@@ -122,7 +133,7 @@ To build only a few of the available utilities:
 $ make UTILS='UTILITY_1 UTILITY_2'
 ```
 
-## Installation Instructions
+## Installation
 
 ### Cargo
 
@@ -212,7 +223,7 @@ run:
 cargo run completion ls bash > /usr/local/share/bash-completion/completions/ls
 ```
 
-## Un-installation Instructions
+## Un-installation
 
 Un-installation differs depending on how you have installed uutils.  If you used
 Cargo to install, use Cargo to uninstall.  If you used GNU Make to install, use
@@ -252,8 +263,9 @@ To uninstall from a custom parent directory:
 # DESTDIR is also supported
 $ make PREFIX=/my/path uninstall
 ```
+<!-- ANCHOR_END: installation (this mark is needed for mdbook) -->
 
-## Test Instructions
+## Testing
 
 Testing can be done using either Cargo or `make`.
 
@@ -319,7 +331,7 @@ To include tests for unimplemented behavior:
 $ make UTILS='UTILITY_1 UTILITY_2' SPEC=y test
 ```
 
-## Run Busybox Tests
+### Run Busybox Tests
 
 This testing functionality is only available on *nix operating systems and
 requires `make`.
@@ -342,7 +354,11 @@ To pass an argument like "-v" to the busybox test runtime
 $ make UTILS='UTILITY_1 UTILITY_2' RUNTEST_ARGS='-v' busytest
 ```
 
-## Comparing with GNU
+### Comparing with GNU
+
+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-docs/user/test_coverage.html).
 
 ![Evolution over time](https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.png?raw=true)
 
@@ -357,7 +373,26 @@ $ bash util/run-gnu-test.sh tests/touch/not-owner.sh # for example
 
 Note that it relies on individual utilities (not the multicall binary).
 
-## Contribute
+### Improving the GNU compatibility
+
+The Python script `./util/remaining-gnu-error.py` shows the list of failing tests in the CI.
+
+To improve the GNU compatibility, the following process is recommended:
+
+1. Identify a test (the smaller, the better) on a program that you understand or is easy to understand. You can use the `./util/remaining-gnu-error.py` script to help with this decision.
+1. Build both the GNU and Rust coreutils using: `bash util/build-gnu.sh`
+1. Run the test with `bash util/run-gnu-test.sh <your test>`
+1. Start to modify `<your test>` to understand what is wrong. Examples:
+    1. Add `set -v` to have the bash verbose mode
+    1. Add `echo $?` where needed
+    1. Bump the content of the output (ex: `cat err`)
+    1. ...
+1. Or, if the test is simple, extract the relevant information to create a new test case running both GNU & Rust implementation
+1. Start to modify the Rust implementation to match the expected behavior
+1. Add a test to make sure that we don't regress (our test suite is super quick)
+
+
+## Contributing
 
 To contribute to uutils, please see [CONTRIBUTING](CONTRIBUTING.md).
 
@@ -371,18 +406,18 @@ To contribute to uutils, please see [CONTRIBUTING](CONTRIBUTING.md).
 | basename  | df        |        |
 | basenc    | expr      |        |
 | cat       | install   |        |
-| chcon     | join      |        |
-| chgrp     | ls        |        |
-| chmod     | more      |        |
-| chown     | numfmt    |        |
-| chroot    | od (`--strings` and 128-bit data types missing) | |
-| cksum     | pr        |        |
-| comm      | printf    |        |
-| csplit    | sort      |        |
-| cut       | split     |        |
-| dircolors | tac       |        |
-| dirname   | tail      |        |
-| du        | test      |        |
+| chcon     | ls        |        |
+| chgrp     | more      |        |
+| chmod     | numfmt    |        |
+| chown     | od (`--strings` and 128-bit data types missing) | |
+| chroot    | pr        |        |
+| cksum     | printf    |        |
+| comm      | sort      |        |
+| csplit    | split     |        |
+| cut       | tac       |        |
+| dircolors | tail      |        |
+| dirname   | test      |        |
+| du        |           |        |
 | echo      |           |        |
 | env       |           |        |
 | expand    |           |        |
@@ -396,16 +431,17 @@ To contribute to uutils, please see [CONTRIBUTING](CONTRIBUTING.md).
 | hostid    |           |        |
 | hostname  |           |        |
 | id        |           |        |
+| join      |           |        |
 | kill      |           |        |
 | link      |           |        |
 | ln        |           |        |
 | logname   |           |        |
-| ~~md5sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/master/src/uu/hashsum/src/hashsum.rs)) | | |
-| ~~sha1sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/master/src/uu/hashsum/src/hashsum.rs)) | | |
-| ~~sha224sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/master/src/uu/hashsum/src/hashsum.rs)) | | |
-| ~~sha256sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/master/src/uu/hashsum/src/hashsum.rs)) | | |
-| ~~sha384sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/master/src/uu/hashsum/src/hashsum.rs)) | | |
-| ~~sha512sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/master/src/uu/hashsum/src/hashsum.rs)) | | |
+| ~~md5sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | | |
+| ~~sha1sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | | |
+| ~~sha224sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | | |
+| ~~sha256sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | | |
+| ~~sha384sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | | |
+| ~~sha512sum~~ (replaced by [hashsum](https://github.com/uutils/coreutils/blob/main/src/uu/hashsum/src/hashsum.rs)) | | |
 | mkdir     |           |        |
 | mkfifo    |           |        |
 | mknod     |           |        |
diff --git a/build.rs b/build.rs
index 261eb5d9a..50b8cfa3f 100644
--- a/build.rs
+++ b/build.rs
@@ -12,29 +12,29 @@ pub fn main() {
         println!("cargo:rustc-cfg=build={:?}", profile);
     }
 
-    let env_feature_prefix: &str = "CARGO_FEATURE_";
-    let feature_prefix: &str = "feat_";
-    let override_prefix: &str = "uu_";
+    const ENV_FEATURE_PREFIX: &str = "CARGO_FEATURE_";
+    const FEATURE_PREFIX: &str = "feat_";
+    const OVERRIDE_PREFIX: &str = "uu_";
 
     let out_dir = env::var("OUT_DIR").unwrap();
     // println!("cargo:warning=out_dir={}", out_dir);
-    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap().replace("\\", "/");
+    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap().replace('\\', "/");
     // println!("cargo:warning=manifest_dir={}", manifest_dir);
     let util_tests_dir = format!("{}/tests/by-util", manifest_dir);
     // println!("cargo:warning=util_tests_dir={}", util_tests_dir);
 
     let mut crates = Vec::new();
     for (key, val) in env::vars() {
-        if val == "1" && key.starts_with(env_feature_prefix) {
-            let krate = key[env_feature_prefix.len()..].to_lowercase();
+        if val == "1" && key.starts_with(ENV_FEATURE_PREFIX) {
+            let krate = key[ENV_FEATURE_PREFIX.len()..].to_lowercase();
             match krate.as_ref() {
                 "default" | "macos" | "unix" | "windows" | "selinux" => continue, // common/standard feature names
                 "nightly" | "test_unimplemented" => continue, // crate-local custom features
                 "test" => continue, // over-ridden with 'uu_test' to avoid collision with rust core crate 'test'
-                s if s.starts_with(feature_prefix) => continue, // crate feature sets
+                s if s.starts_with(FEATURE_PREFIX) => continue, // crate feature sets
                 _ => {}             // util feature name
             }
-            crates.push(krate.to_string());
+            crates.push(krate);
         }
     }
     crates.sort();
@@ -43,33 +43,23 @@ pub fn main() {
     let mut tf = File::create(Path::new(&out_dir).join("test_modules.rs")).unwrap();
 
     mf.write_all(
-        "type UtilityMap<T> = HashMap<&'static str, (fn(T) -> i32, fn() -> App<'static, 'static>)>;\n\
+        "type UtilityMap<T> = phf::Map<&'static str, (fn(T) -> i32, fn() -> Command<'static>)>;\n\
          \n\
-         fn util_map<T: uucore::Args>() -> UtilityMap<T> {\n\
-         \t#[allow(unused_mut)]\n\
-         \t#[allow(clippy::let_and_return)]\n\
-         \tlet mut map = UtilityMap::new();\n\
-         "
-        .as_bytes(),
+         fn util_map<T: uucore::Args>() -> UtilityMap<T> {\n"
+            .as_bytes(),
     )
     .unwrap();
 
-    for krate in crates {
+    let mut phf_map = phf_codegen::Map::<&str>::new();
+    for krate in &crates {
+        let map_value = format!("({krate}::uumain, {krate}::uu_app)", krate = krate);
         match krate.as_ref() {
             // 'test' is named uu_test to avoid collision with rust core crate 'test'.
             // It can also be invoked by name '[' for the '[ expr ] syntax'.
             "uu_test" => {
-                mf.write_all(
-                    format!(
-                        "\
-                         \tmap.insert(\"test\", ({krate}::uumain, {krate}::uu_app));\n\
-                         \t\tmap.insert(\"[\", ({krate}::uumain, {krate}::uu_app));\n\
-                         ",
-                        krate = krate
-                    )
-                    .as_bytes(),
-                )
-                .unwrap();
+                phf_map.entry("test", &map_value);
+                phf_map.entry("[", &map_value);
+
                 tf.write_all(
                     format!(
                         "#[path=\"{dir}/test_test.rs\"]\nmod test_test;\n",
@@ -77,37 +67,25 @@ pub fn main() {
                     )
                     .as_bytes(),
                 )
-                .unwrap()
-            }
-            k if k.starts_with(override_prefix) => {
-                mf.write_all(
-                    format!(
-                        "\tmap.insert(\"{k}\", ({krate}::uumain, {krate}::uu_app));\n",
-                        k = krate[override_prefix.len()..].to_string(),
-                        krate = krate
-                    )
-                    .as_bytes(),
-                )
                 .unwrap();
+            }
+            k if k.starts_with(OVERRIDE_PREFIX) => {
+                phf_map.entry(&k[OVERRIDE_PREFIX.len()..], &map_value);
                 tf.write_all(
                     format!(
                         "#[path=\"{dir}/test_{k}.rs\"]\nmod test_{k};\n",
-                        k = krate[override_prefix.len()..].to_string(),
+                        k = &krate[OVERRIDE_PREFIX.len()..],
                         dir = util_tests_dir,
                     )
                     .as_bytes(),
                 )
-                .unwrap()
+                .unwrap();
             }
             "false" | "true" => {
-                mf.write_all(
-                    format!(
-                        "\tmap.insert(\"{krate}\", (r#{krate}::uumain, r#{krate}::uu_app));\n",
-                        krate = krate
-                    )
-                    .as_bytes(),
-                )
-                .unwrap();
+                phf_map.entry(
+                    krate,
+                    &format!("(r#{krate}::uumain, r#{krate}::uu_app)", krate = krate),
+                );
                 tf.write_all(
                     format!(
                         "#[path=\"{dir}/test_{krate}.rs\"]\nmod test_{krate};\n",
@@ -116,32 +94,30 @@ pub fn main() {
                     )
                     .as_bytes(),
                 )
-                .unwrap()
+                .unwrap();
             }
             "hashsum" => {
-                mf.write_all(
-                    format!(
-                        "\
-                         \tmap.insert(\"{krate}\", ({krate}::uumain, {krate}::uu_app_custom));\n\
-                         \t\tmap.insert(\"md5sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha1sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha224sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha256sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha384sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha512sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha3sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha3-224sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha3-256sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha3-384sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"sha3-512sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"shake128sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         \t\tmap.insert(\"shake256sum\", ({krate}::uumain, {krate}::uu_app_common));\n\
-                         ",
-                        krate = krate
-                    )
-                    .as_bytes(),
-                )
-                .unwrap();
+                phf_map.entry(
+                    krate,
+                    &format!("({krate}::uumain, {krate}::uu_app_custom)", krate = krate),
+                );
+
+                let map_value = format!("({krate}::uumain, {krate}::uu_app_common)", krate = krate);
+                phf_map.entry("md5sum", &map_value);
+                phf_map.entry("sha1sum", &map_value);
+                phf_map.entry("sha224sum", &map_value);
+                phf_map.entry("sha256sum", &map_value);
+                phf_map.entry("sha384sum", &map_value);
+                phf_map.entry("sha512sum", &map_value);
+                phf_map.entry("sha3sum", &map_value);
+                phf_map.entry("sha3-224sum", &map_value);
+                phf_map.entry("sha3-256sum", &map_value);
+                phf_map.entry("sha3-384sum", &map_value);
+                phf_map.entry("sha3-512sum", &map_value);
+                phf_map.entry("shake128sum", &map_value);
+                phf_map.entry("shake256sum", &map_value);
+                phf_map.entry("b2sum", &map_value);
+                phf_map.entry("b3sum", &map_value);
                 tf.write_all(
                     format!(
                         "#[path=\"{dir}/test_{krate}.rs\"]\nmod test_{krate};\n",
@@ -150,17 +126,10 @@ pub fn main() {
                     )
                     .as_bytes(),
                 )
-                .unwrap()
+                .unwrap();
             }
             _ => {
-                mf.write_all(
-                    format!(
-                        "\tmap.insert(\"{krate}\", ({krate}::uumain, {krate}::uu_app));\n",
-                        krate = krate
-                    )
-                    .as_bytes(),
-                )
-                .unwrap();
+                phf_map.entry(krate, &map_value);
                 tf.write_all(
                     format!(
                         "#[path=\"{dir}/test_{krate}.rs\"]\nmod test_{krate};\n",
@@ -169,12 +138,12 @@ pub fn main() {
                     )
                     .as_bytes(),
                 )
-                .unwrap()
+                .unwrap();
             }
         }
     }
-
-    mf.write_all(b"map\n}\n").unwrap();
+    write!(mf, "{}", phf_map.build()).unwrap();
+    mf.write_all(b"\n}\n").unwrap();
 
     mf.flush().unwrap();
     tf.flush().unwrap();
diff --git a/clippy.toml b/clippy.toml
deleted file mode 100644
index dbabdab50..000000000
--- a/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-msrv = "1.47.0"
diff --git a/deny.toml b/deny.toml
new file mode 100644
index 000000000..dea3503de
--- /dev/null
+++ b/deny.toml
@@ -0,0 +1,95 @@
+# spell-checker:ignore SSLeay RUSTSEC
+
+# This section is considered when running `cargo deny check advisories`
+# More documentation for the advisories section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
+[advisories]
+db-path = "~/.cargo/advisory-db"
+db-urls = ["https://github.com/rustsec/advisory-db"]
+vulnerability = "warn"
+unmaintained = "warn"
+yanked = "warn"
+notice = "warn"
+ignore = [
+    #"RUSTSEC-0000-0000",
+]
+
+# This section is considered when running `cargo deny check licenses`
+# More documentation for the licenses section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
+[licenses]
+unlicensed = "deny"
+allow = [
+    "MIT",
+    "Apache-2.0",
+    "ISC",
+    "BSD-2-Clause",
+    "BSD-2-Clause-FreeBSD",
+    "BSD-3-Clause",
+    "CC0-1.0",
+    "MPL-2.0", # XXX considered copyleft?
+]
+copyleft = "deny"
+allow-osi-fsf-free = "neither"
+default = "deny"
+confidence-threshold = 0.8
+exceptions = [
+    { allow = ["OpenSSL"], name = "ring" },
+]
+
+[[licenses.clarify]]
+name = "ring"
+# SPDX considers OpenSSL to encompass both the OpenSSL and SSLeay licenses
+# https://spdx.org/licenses/OpenSSL.html
+# ISC - Both BoringSSL and ring use this for their new files
+# MIT - "Files in third_party/ have their own licenses, as described therein. The MIT
+# license, for third_party/fiat, which, unlike other third_party directories, is
+# compiled into non-test libraries, is included below."
+# OpenSSL - Obviously
+expression = "ISC AND MIT AND OpenSSL"
+license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]
+
+# This section is considered when running `cargo deny check bans`.
+# More documentation about the 'bans' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
+[bans]
+multiple-versions = "deny"
+wildcards = "allow"
+highlight = "all"
+
+# For each duplicate dependency, indicate the name of the dependency which
+# introduces it.
+# spell-checker: disable
+skip = [
+    # blake2d_simd
+    { name = "arrayvec", version = "=0.7.2" },
+    # flimit/unix_socket
+    { name = "cfg-if", version = "=0.1.10" },
+    # ordered-multimap
+    { name = "hashbrown", version = "=0.9.1" },
+    # kernel32-sys
+    { name = "winapi", version = "=0.2.8" },
+    # bindgen 0.59.2
+    { name = "clap", version = "=2.34.0" },
+    { name = "strsim", version = "=0.8.0" },
+    { name = "textwrap", version = "=0.11.0" },
+    { name = "cpp_common", version = "=0.4.0" },
+    # quickcheck
+    { name = "env_logger", version = "=0.8.4" },
+    # cpp_*
+    { name = "memchr", version = "=1.0.2" },
+    { name = "quote", version = "=0.3.15" },
+    { name = "unicode-xid", version = "=0.0.4" },
+    # exacl
+    { name = "nix", version = "=0.21.0" },
+]
+# spell-checker: enable
+
+# This section is considered when running `cargo deny check sources`.
+# More documentation about the 'sources' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html
+[sources]
+unknown-registry = "warn"
+unknown-git = "warn"
+allow-registry = ["https://github.com/rust-lang/crates.io-index"]
+allow-git = []
diff --git a/docs/.gitignore b/docs/.gitignore
new file mode 100644
index 000000000..f2b5c7168
--- /dev/null
+++ b/docs/.gitignore
@@ -0,0 +1,3 @@
+book
+src/utils
+src/SUMMARY.md
diff --git a/docs/GNUmakefile b/docs/GNUmakefile
deleted file mode 100644
index 49d827da8..000000000
--- a/docs/GNUmakefile
+++ /dev/null
@@ -1,21 +0,0 @@
-# spell-checker:ignore (vars/env) SPHINXOPTS SPHINXBUILD SPHINXPROJ SOURCEDIR BUILDDIR
-
-# Minimal makefile for Sphinx documentation
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = sphinx-build
-SPHINXPROJ    = uutils
-SOURCEDIR     = .
-BUILDDIR      = _build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help GNUmakefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: GNUmakefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/docs/Makefile b/docs/Makefile
index f56df90fb..7372b3868 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -1,5 +1,4 @@
-UseGNU=gmake $*
-all:
-	@$(UseGNU)
-.DEFAULT:
-	@$(UseGNU)
+clean:
+	rm -rf book
+	rm -f src/SUMMARY.md
+	rm -f src/utils/*
diff --git a/docs/arch.rst b/docs/arch.rst
deleted file mode 100644
index 66b516159..000000000
--- a/docs/arch.rst
+++ /dev/null
@@ -1,28 +0,0 @@
-.. print machine hardware name
-
-====
-arch
-====
-
-.. FIXME: this needs to be autogenerated somehow
-
---------
-Synopsis
---------
-
-``arch`` [OPTION]...
-
------------
-Description
------------
-
-``arch`` is an alias for ``uname -m``.  They both print the machine hardware
-name.
-
-An exit code of zero indicates success, whereas anything else means failure.
-For this program, a non-zero exit code generally means the user provided
-invalid options.
-
--h, --help       print a help menu for this program displaying accepted
-                 options and arguments
--v, --version    print the version number of this program
diff --git a/docs/book.toml b/docs/book.toml
new file mode 100644
index 000000000..75982ab31
--- /dev/null
+++ b/docs/book.toml
@@ -0,0 +1,9 @@
+[book]
+authors = ["uutils contributors"]
+language = "en"
+multilingual = false
+src = "src"
+title = "uutils Documentation"
+
+[output.html]
+git-repository-url = "https://github.com/rust-lang/cargo/tree/master/src/doc/src"
\ No newline at end of file
diff --git a/docs/compiles_table.py b/docs/compiles_table.py
index aa1b8703c..e2c4c0a8d 100644
--- a/docs/compiles_table.py
+++ b/docs/compiles_table.py
@@ -40,6 +40,8 @@ TARGETS = [
     "x86_64-linux-android",
     # Solaris
     "x86_64-sun-solaris",
+    # Illumos
+    "x86_64-unknown-illumos",
     # WASM
     "wasm32-wasi",
     # Redox
diff --git a/docs/conf.py b/docs/conf.py
deleted file mode 100644
index 5a1213627..000000000
--- a/docs/conf.py
+++ /dev/null
@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# uutils documentation build configuration file, created by
-# sphinx-quickstart on Tue Dec  5 23:20:18 2017.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-
-# spell-checker:ignore (words) howto htbp imgmath toctree todos uutilsdoc
-
-import glob
-import os
-import re
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = ['sphinx.ext.imgmath']
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = 'uutils'
-copyright = '2017, uutils developers'
-author = 'uutils developers'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-# * take version from project "Cargo.toml"
-version_file = open(os.path.join("..","Cargo.toml"), "r")
-version_file_content = version_file.read()
-v = re.search("^\s*version\s*=\s*\"([0-9.]+)\"", version_file_content, re.IGNORECASE | re.MULTILINE)
-# The short X.Y version.
-version = v.groups()[0]
-# The full version, including alpha/beta/rc tags.
-release = version
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = False
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = 'alabaster'
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-# html_theme_options = {}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Custom sidebar templates, must be a dictionary that maps document names
-# to template names.
-#
-# This is required for the alabaster theme
-# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
-html_sidebars = {
-    '**': [
-        'relations.html',  # needs 'show_related': True theme option to display
-        'searchbox.html',
-    ]
-}
-
-
-# -- Options for HTMLHelp output ------------------------------------------
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'uutilsdoc'
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    #
-    # 'papersize': 'letterpaper',
-
-    # The font size ('10pt', '11pt' or '12pt').
-    #
-    # 'pointsize': '10pt',
-
-    # Additional stuff for the LaTeX preamble.
-    #
-    # 'preamble': '',
-
-    # Latex figure (float) alignment
-    #
-    # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, 'uutils.tex', 'uutils Documentation',
-     'uutils developers', 'manual'),
-]
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = []
-for name in glob.glob('*.rst'):
-    if name != 'index.rst':
-        desc = ''
-        with open(name) as f:
-            desc = f.readline().strip()
-            if desc.startswith('..'):
-                desc = desc[2:].strip()
-            else:
-                desc = ''
-        man_pages.append((
-            name[:-4],     # source file without extension
-            name[:-4].replace('/', '-'),       # output file
-            desc,
-            [author],
-            1
-        ))
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (master_doc, 'uutils', 'uutils Documentation',
-     author, 'uutils', 'A cross-platform implementation of GNU coreutils, written in Rust.',
-     'Miscellaneous'),
-]
diff --git a/docs/index.rst b/docs/index.rst
deleted file mode 100644
index 7f782b12a..000000000
--- a/docs/index.rst
+++ /dev/null
@@ -1,24 +0,0 @@
-.. uutils documentation master file, created by
-   sphinx-quickstart on Tue Dec  5 23:20:18 2017.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-..
-   spell-checker:ignore (directives) genindex maxdepth modindex toctree ; (misc) quickstart
-
-Welcome to uutils' documentation!
-=================================
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Contents:
-
-   arch
-   uutils
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`
diff --git a/docs/make.bat b/docs/make.bat
deleted file mode 100644
index 6e63e3baa..000000000
--- a/docs/make.bat
+++ /dev/null
@@ -1,39 +0,0 @@
-@setLocal
-@ECHO OFF
-
-rem spell-checker:ignore (vars/env) BUILDDIR SOURCEDIR SPHINXBUILD SPHINXOPTS SPHINXPROJ
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-    set SPHINXBUILD=sphinx-build
-)
-set SOURCEDIR=.
-set BUILDDIR=_build
-set SPHINXPROJ=uutils
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if ErrorLevel 9009 (
-    echo.
-    echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-    echo.installed, then set the SPHINXBUILD environment variable to point
-    echo.to the full path of the 'sphinx-build' executable. Alternatively you
-    echo.may add the Sphinx directory to PATH.
-    echo.
-    echo.If you don't have Sphinx installed, grab it from
-    echo.http://sphinx-doc.org/
-    exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-
-:end
-popd
diff --git a/docs/src/contributing.md b/docs/src/contributing.md
new file mode 100644
index 000000000..79ef4d13b
--- /dev/null
+++ b/docs/src/contributing.md
@@ -0,0 +1 @@
+{{ #include ../../CONTRIBUTING.md }}
\ No newline at end of file
diff --git a/docs/src/index.md b/docs/src/index.md
new file mode 100644
index 000000000..3ea5d913a
--- /dev/null
+++ b/docs/src/index.md
@@ -0,0 +1,20 @@
+# uutils Coreutils Documentation
+
+uutils is an attempt at writing universal (as in cross-platform) CLI
+utilities in [Rust](https://www.rust-lang.org). It is available for
+Linux, Windows, Mac and other platforms.
+
+The API reference for `uucore`, the library of functions shared between
+various utils, is hosted at at
+[docs.rs](https://docs.rs/uucore/latest/uucore/).
+
+uutils is licensed under the [MIT License](https://github.com/uutils/coreutils/blob/main/LICENSE).
+
+## Useful links
+* [Releases](https://github.com/uutils/coreutils/releases)
+* [Source Code](https://github.com/uutils/coreutils)
+* [Issues](https://github.com/uutils/coreutils/issues)
+* [Discord](https://discord.gg/wQVJbvJ)
+
+> Note: This manual is automatically generated from the source code and is
+> a work in progress.
\ No newline at end of file
diff --git a/docs/src/installation.md b/docs/src/installation.md
new file mode 100644
index 000000000..885b5ecb0
--- /dev/null
+++ b/docs/src/installation.md
@@ -0,0 +1,3 @@
+# Installation
+
+{{#include ../../README.md:installation }}
\ No newline at end of file
diff --git a/docs/src/multicall.md b/docs/src/multicall.md
new file mode 100644
index 000000000..5d7b8b169
--- /dev/null
+++ b/docs/src/multicall.md
@@ -0,0 +1,17 @@
+#  Multi-call binary
+uutils includes a multi-call binary from which the utils can be invoked. This
+reduces the binary size of the binary and can be useful for portability.
+
+The first argument of the multi-call binary is the util to run, after which
+the regular arguments to the util can be passed.
+
+```shell
+coreutils [util] [util options]
+```
+
+The `--help` flag will print a list of available utils.
+
+## Example
+```
+coreutils ls -l
+```
\ No newline at end of file
diff --git a/docs/src/test_coverage.css b/docs/src/test_coverage.css
new file mode 100644
index 000000000..37a658695
--- /dev/null
+++ b/docs/src/test_coverage.css
@@ -0,0 +1,46 @@
+:root {
+    --PASS: #44AF69;
+    --ERROR: #F8333C;
+    --FAIL: #F8333C;
+    --SKIP: #d3c994;
+}
+.PASS {
+    color: var(--PASS);
+}
+.ERROR {
+    color: var(--ERROR);
+}
+.FAIL {
+    color: var(--FAIL);
+}
+.SKIP {
+    color: var(--SKIP);
+}
+.testSummary {
+    display: inline-flex;
+    align-items: center;
+    justify-content: space-between;
+    width: 90%;
+}
+.progress {
+    width: 80%;
+    display: flex;
+    justify-content: right;
+    align-items: center;
+}
+.progress-bar {
+    height: 10px;
+    width: calc(100% - 15ch);
+    border-radius: 5px;
+}
+.result {
+    font-weight: bold;
+    width: 7ch;
+    display: inline-block;
+}
+.result-line {
+    margin: 8px;
+}
+.counts {
+    margin-right: 10px;
+}
\ No newline at end of file
diff --git a/docs/src/test_coverage.js b/docs/src/test_coverage.js
new file mode 100644
index 000000000..e601229af
--- /dev/null
+++ b/docs/src/test_coverage.js
@@ -0,0 +1,82 @@
+// spell-checker:ignore hljs
+function progressBar(totals) {
+	const bar = document.createElement("div");
+	bar.className = "progress-bar";
+	let totalTests = 0;
+	for (const [key, value] of Object.entries(totals)) {
+		totalTests += value;
+	}
+	const passPercentage = Math.round(100 * totals["PASS"] / totalTests);
+	const skipPercentage = passPercentage + Math.round(100 * totals["SKIP"] / totalTests);
+
+	// The ternary expressions are used for some edge-cases where there are no failing test,
+	// but still a red (or beige) line shows up because of how CSS draws gradients.
+	bar.style = `background: linear-gradient(
+        to right,
+        var(--PASS) ${passPercentage}%`
+		+ ( passPercentage === 100 ? ", var(--PASS)" :
+        `, var(--SKIP) ${passPercentage}%,
+        var(--SKIP) ${skipPercentage}%`
+		)
+        + (skipPercentage === 100 ? ")" : ", var(--FAIL) 0)");
+	
+	const progress = document.createElement("div");
+	progress.className = "progress"
+	progress.innerHTML = `
+		<span class="counts">
+		<span class="PASS">${totals["PASS"]}</span>
+		/
+		<span class="SKIP">${totals["SKIP"]}</span>
+		/
+		<span class="FAIL">${totals["FAIL"] + totals["ERROR"]}</span>
+		</span>
+	`;
+	progress.appendChild(bar);
+	return progress
+}
+
+function parse_result(parent, obj) {
+	const totals = {
+		PASS: 0,
+		SKIP: 0,
+		FAIL: 0,
+		ERROR: 0,
+	};
+	for (const [category, content] of Object.entries(obj)) {
+		if (typeof content === "string") {
+			const p = document.createElement("p");
+			p.className = "result-line";
+			totals[content]++;
+			p.innerHTML = `<span class="result" style="color: var(--${content})">${content}</span> ${category}`;
+			parent.appendChild(p);
+		} else {
+			const categoryName = document.createElement("code");
+			categoryName.innerHTML = category;
+			categoryName.className = "hljs";
+
+			const details = document.createElement("details");
+			const subtotals = parse_result(details, content);
+			for (const [subtotal, count] of Object.entries(subtotals)) {
+				totals[subtotal] += count;
+			}
+			const summaryDiv = document.createElement("div");
+			summaryDiv.className = "testSummary";
+			summaryDiv.appendChild(categoryName);
+			summaryDiv.appendChild(progressBar(subtotals));
+
+			const summary = document.createElement("summary");
+			summary.appendChild(summaryDiv);
+
+			details.appendChild(summary);
+			parent.appendChild(details);
+		}
+	}
+	return totals;
+}
+
+fetch("https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json")
+	.then((r) => r.json())
+	.then((obj) => {
+		let parent = document.getElementById("test-cov");
+		parse_result(parent, obj);
+	});
diff --git a/docs/src/test_coverage.md b/docs/src/test_coverage.md
new file mode 100644
index 000000000..bf4c72129
--- /dev/null
+++ b/docs/src/test_coverage.md
@@ -0,0 +1,19 @@
+# GNU Test Coverage
+
+uutils is actively tested against the GNU coreutils test suite. The results
+below are automatically updated every day.
+
+## Coverage per category
+
+Click on the categories to see the names of the tests. Green indicates a passing
+test, yellow indicates a skipped test and red means that the test either failed
+or resulted in an error.
+
+<link rel="stylesheet" href="test_coverage.css">
+<script src="test_coverage.js"></script>
+
+<div id="test-cov"></div>
+
+## Progress over time
+
+<image src="https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.png?raw=true">
diff --git a/docs/theme/favicon.png b/docs/theme/favicon.png
new file mode 100644
index 000000000..1cd1f26ec
Binary files /dev/null and b/docs/theme/favicon.png differ
diff --git a/docs/theme/head.hbs b/docs/theme/head.hbs
new file mode 100644
index 000000000..31cc2dad5
--- /dev/null
+++ b/docs/theme/head.hbs
@@ -0,0 +1,16 @@
+<style>
+    dd {
+        margin-bottom: 1em;
+    }
+    main {
+        position: relative;
+    }
+    .version {
+        position: absolute;
+        top: 1em;
+        right: 0;
+    }
+    dd > p {
+        margin-top: 0.2em;
+    }
+</style>
diff --git a/docs/uutils.rst b/docs/uutils.rst
deleted file mode 100644
index e3b8c6a1a..000000000
--- a/docs/uutils.rst
+++ /dev/null
@@ -1,24 +0,0 @@
-.. run core utilities
-
-======
-uutils
-======
-
-.. FIXME: this needs to be autogenerated somehow
-
---------
-Synopsis
---------
-
-``uutils`` [OPTION]... [PROGRAM] [OPTION]... [ARGUMENTS]...
-
------------
-Description
------------
-
-``uutils`` is a program that contains other coreutils commands, somewhat
-similar to Busybox.
-
---help, -h      print a help menu for PROGRAM displaying accepted options and
-                arguments; if PROGRAM was not given, do the same but for this
-                program
diff --git a/renovate.json b/renovate.json
new file mode 100644
index 000000000..9dc8c6919
--- /dev/null
+++ b/renovate.json
@@ -0,0 +1,5 @@
+{
+	"extends": [
+		"config:base"
+	]
+}
diff --git a/src/bin/coreutils.rs b/src/bin/coreutils.rs
index 1de1b6354..7a8986035 100644
--- a/src/bin/coreutils.rs
+++ b/src/bin/coreutils.rs
@@ -5,11 +5,9 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use clap::App;
-use clap::Arg;
-use clap::Shell;
+use clap::{Arg, Command};
+use clap_complete::Shell;
 use std::cmp;
-use std::collections::hash_map::HashMap;
 use std::ffi::OsStr;
 use std::ffi::OsString;
 use std::io::{self, Write};
@@ -65,7 +63,7 @@ fn main() {
     // * prefix/stem may be any string ending in a non-alphanumeric character
     let util_name = if let Some(util) = utils.keys().find(|util| {
         binary_as_util.ends_with(*util)
-            && !(&binary_as_util[..binary_as_util.len() - (*util).len()])
+            && !binary_as_util[..binary_as_util.len() - (*util).len()]
                 .ends_with(char::is_alphanumeric)
     }) {
         // prefixed util => replace 0th (aka, executable name) argument
@@ -89,7 +87,7 @@ fn main() {
         };
 
         if util == "completion" {
-            gen_completions(args, utils);
+            gen_completions(args, &utils);
         }
 
         match utils.get(util) {
@@ -134,22 +132,22 @@ fn main() {
 /// Prints completions for the utility in the first parameter for the shell in the second parameter to stdout
 fn gen_completions<T: uucore::Args>(
     args: impl Iterator<Item = OsString>,
-    util_map: UtilityMap<T>,
+    util_map: &UtilityMap<T>,
 ) -> ! {
     let all_utilities: Vec<_> = std::iter::once("coreutils")
         .chain(util_map.keys().copied())
         .collect();
 
-    let matches = App::new("completion")
+    let matches = Command::new("completion")
         .about("Prints completions to stdout")
         .arg(
-            Arg::with_name("utility")
-                .possible_values(&all_utilities)
+            Arg::new("utility")
+                .possible_values(all_utilities)
                 .required(true),
         )
         .arg(
-            Arg::with_name("shell")
-                .possible_values(&Shell::variants())
+            Arg::new("shell")
+                .possible_values(Shell::possible_values())
                 .required(true),
         )
         .get_matches_from(std::iter::once(OsString::from("completion")).chain(args));
@@ -157,7 +155,7 @@ fn gen_completions<T: uucore::Args>(
     let utility = matches.value_of("utility").unwrap();
     let shell = matches.value_of("shell").unwrap();
 
-    let mut app = if utility == "coreutils" {
+    let mut command = if utility == "coreutils" {
         gen_coreutils_app(util_map)
     } else {
         util_map.get(utility).unwrap().1()
@@ -165,15 +163,15 @@ fn gen_completions<T: uucore::Args>(
     let shell: Shell = shell.parse().unwrap();
     let bin_name = std::env::var("PROG_PREFIX").unwrap_or_default() + utility;
 
-    app.gen_completions_to(bin_name, shell, &mut io::stdout());
+    clap_complete::generate(shell, &mut command, bin_name, &mut io::stdout());
     io::stdout().flush().unwrap();
     process::exit(0);
 }
 
-fn gen_coreutils_app<T: uucore::Args>(util_map: UtilityMap<T>) -> App<'static, 'static> {
-    let mut app = App::new("coreutils");
+fn gen_coreutils_app<T: uucore::Args>(util_map: &UtilityMap<T>) -> Command<'static> {
+    let mut command = Command::new("coreutils");
     for (_, (_, sub_app)) in util_map {
-        app = app.subcommand(sub_app());
+        command = command.subcommand(sub_app());
     }
-    app
+    command
 }
diff --git a/src/bin/uudoc.rs b/src/bin/uudoc.rs
new file mode 100644
index 000000000..24c347fe7
--- /dev/null
+++ b/src/bin/uudoc.rs
@@ -0,0 +1,211 @@
+// 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 tldr
+
+use clap::Command;
+use std::ffi::OsString;
+use std::fs::File;
+use std::io::Cursor;
+use std::io::{self, Read, Seek, Write};
+use zip::ZipArchive;
+
+include!(concat!(env!("OUT_DIR"), "/uutils_map.rs"));
+
+fn main() -> io::Result<()> {
+    println!("Downloading tldr archive");
+    let mut zip_reader = ureq::get("https://tldr.sh/assets/tldr.zip")
+        .call()
+        .unwrap()
+        .into_reader();
+    let mut buffer = Vec::new();
+    zip_reader.read_to_end(&mut buffer).unwrap();
+    let mut tldr_zip = ZipArchive::new(Cursor::new(buffer)).unwrap();
+
+    let utils = util_map::<Box<dyn Iterator<Item = OsString>>>();
+    match std::fs::create_dir("docs/src/utils/") {
+        Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Ok(()),
+        x => x,
+    }?;
+
+    let mut summary = File::create("docs/src/SUMMARY.md")?;
+
+    let _ = write!(
+        summary,
+        "# Summary\n\
+        \n\
+        [Introduction](index.md)\n\
+        * [Installation](installation.md)\n\
+        * [Contributing](contributing.md)\n\
+        * [GNU test coverage](test_coverage.md)\n\
+        \n\
+        # Reference\n\
+        * [Multi-call binary](multicall.md)\n",
+    );
+
+    let mut utils = utils.entries().collect::<Vec<_>>();
+    utils.sort();
+    for (&name, (_, command)) in utils {
+        if name == "[" {
+            continue;
+        }
+        let p = format!("docs/src/utils/{}.md", name);
+        if let Ok(f) = File::create(&p) {
+            write_markdown(f, &mut command(), name, &mut tldr_zip)?;
+            println!("Wrote to '{}'", p);
+        } else {
+            println!("Error writing to {}", p);
+        }
+        writeln!(summary, "* [{0}](utils/{0}.md)", name)?;
+    }
+    Ok(())
+}
+
+fn write_markdown(
+    mut w: impl Write,
+    command: &mut Command,
+    name: &str,
+    tldr_zip: &mut zip::ZipArchive<impl Read + Seek>,
+) -> io::Result<()> {
+    write!(w, "# {}\n\n", name)?;
+    write_version(&mut w, command)?;
+    write_usage(&mut w, command, name)?;
+    write_description(&mut w, command)?;
+    write_options(&mut w, command)?;
+    write_examples(&mut w, name, tldr_zip)
+}
+
+fn write_version(w: &mut impl Write, command: &Command) -> io::Result<()> {
+    writeln!(
+        w,
+        "<div class=\"version\">version: {}</div>",
+        command.render_version().split_once(' ').unwrap().1
+    )
+}
+
+fn write_usage(w: &mut impl Write, command: &mut Command, name: &str) -> io::Result<()> {
+    writeln!(w, "\n```")?;
+    let mut usage: String = command
+        .render_usage()
+        .lines()
+        .skip(1)
+        .map(|l| l.trim())
+        .filter(|l| !l.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n");
+    usage = usage.replace(uucore::execution_phrase(), name);
+    writeln!(w, "{}", usage)?;
+    writeln!(w, "```")
+}
+
+fn write_description(w: &mut impl Write, command: &Command) -> io::Result<()> {
+    if let Some(about) = command.get_long_about().or_else(|| command.get_about()) {
+        writeln!(w, "{}", about)
+    } else {
+        Ok(())
+    }
+}
+
+fn write_examples(
+    w: &mut impl Write,
+    name: &str,
+    tldr_zip: &mut zip::ZipArchive<impl Read + Seek>,
+) -> io::Result<()> {
+    let content = if let Some(f) = get_zip_content(tldr_zip, &format!("pages/common/{}.md", name)) {
+        f
+    } else if let Some(f) = get_zip_content(tldr_zip, &format!("pages/linux/{}.md", name)) {
+        f
+    } else {
+        return Ok(());
+    };
+
+    writeln!(w, "## Examples")?;
+    writeln!(w)?;
+    for line in content.lines().skip_while(|l| !l.starts_with('-')) {
+        if let Some(l) = line.strip_prefix("- ") {
+            writeln!(w, "{}", l)?;
+        } else if line.starts_with('`') {
+            writeln!(w, "```shell\n{}\n```", line.trim_matches('`'))?;
+        } else if line.is_empty() {
+            writeln!(w)?;
+        } else {
+            println!("Not sure what to do with this line:");
+            println!("{}", line);
+        }
+    }
+    writeln!(w)?;
+    writeln!(
+        w,
+        "> The examples are provided by the [tldr-pages project](https://tldr.sh) under the [CC BY 4.0 License](https://github.com/tldr-pages/tldr/blob/main/LICENSE.md)."
+    )?;
+    writeln!(w, ">")?;
+    writeln!(
+        w,
+        "> Please note that, as uutils is a work in progress, some examples might fail."
+    )
+}
+
+fn get_zip_content(archive: &mut ZipArchive<impl Read + Seek>, name: &str) -> Option<String> {
+    let mut s = String::new();
+    archive.by_name(name).ok()?.read_to_string(&mut s).unwrap();
+    Some(s)
+}
+
+fn write_options(w: &mut impl Write, command: &Command) -> io::Result<()> {
+    writeln!(w, "<h2>Options</h2>")?;
+    write!(w, "<dl>")?;
+    for arg in command.get_arguments() {
+        write!(w, "<dt>")?;
+        let mut first = true;
+        for l in arg.get_long_and_visible_aliases().unwrap_or_default() {
+            if !first {
+                write!(w, ", ")?;
+            } else {
+                first = false;
+            }
+            write!(w, "<code>")?;
+            write!(w, "--{}", l)?;
+            if let Some(names) = arg.get_value_names() {
+                write!(
+                    w,
+                    "={}",
+                    names
+                        .iter()
+                        .map(|x| format!("&lt;{}&gt;", x))
+                        .collect::<Vec<_>>()
+                        .join(" ")
+                )?;
+            }
+            write!(w, "</code>")?;
+        }
+        for s in arg.get_short_and_visible_aliases().unwrap_or_default() {
+            if !first {
+                write!(w, ", ")?;
+            } else {
+                first = false;
+            }
+            write!(w, "<code>")?;
+            write!(w, "-{}", s)?;
+            if let Some(names) = arg.get_value_names() {
+                write!(
+                    w,
+                    " {}",
+                    names
+                        .iter()
+                        .map(|x| format!("&lt;{}&gt;", x))
+                        .collect::<Vec<_>>()
+                        .join(" ")
+                )?;
+            }
+            write!(w, "</code>")?;
+        }
+        writeln!(w, "</dt>")?;
+        writeln!(
+            w,
+            "<dd>\n\n{}\n\n</dd>",
+            arg.get_help().unwrap_or_default().replace('\n', "<br />")
+        )?;
+    }
+    writeln!(w, "</dl>\n")
+}
diff --git a/src/uu/arch/Cargo.toml b/src/uu/arch/Cargo.toml
index c7fc4f9f9..588520fa3 100644
--- a/src/uu/arch/Cargo.toml
+++ b/src/uu/arch/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_arch"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "arch ~ (uutils) display machine architecture"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/arch"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/arch"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/arch.rs"
 
 [dependencies]
-platform-info = "0.1"
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+platform-info = "0.2"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "arch"
diff --git a/src/uu/arch/LICENSE b/src/uu/arch/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/arch/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/arch/src/arch.rs b/src/uu/arch/src/arch.rs
index d23a11cc8..502e2d5a0 100644
--- a/src/uu/arch/src/arch.rs
+++ b/src/uu/arch/src/arch.rs
@@ -8,13 +8,13 @@
 
 use platform_info::*;
 
-use clap::{crate_version, App};
+use clap::{crate_version, Command};
 use uucore::error::{FromIo, UResult};
 
 static ABOUT: &str = "Display machine architecture";
 static SUMMARY: &str = "Determine architecture name for current machine.";
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     uu_app().get_matches_from(args);
 
@@ -23,9 +23,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(SUMMARY)
+        .infer_long_args(true)
 }
diff --git a/src/uu/arch/src/main.rs b/src/uu/arch/src/main.rs
index e2668864c..a47da8346 100644
--- a/src/uu/arch/src/main.rs
+++ b/src/uu/arch/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_arch);
+uucore::bin!(uu_arch);
diff --git a/src/uu/base32/Cargo.toml b/src/uu/base32/Cargo.toml
index d5fc40024..c5d54133e 100644
--- a/src/uu/base32/Cargo.toml
+++ b/src/uu/base32/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_base32"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "base32 ~ (uutils) decode/encode input (base32-encoding)"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/base32"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/base32"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/base32.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features = ["encoding"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features = ["encoding"] }
 
 [[bin]]
 name = "base32"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/base32/LICENSE b/src/uu/base32/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/base32/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/base32/src/base32.rs b/src/uu/base32/src/base32.rs
index f4b4b49de..4260c472e 100644
--- a/src/uu/base32/src/base32.rs
+++ b/src/uu/base32/src/base32.rs
@@ -7,31 +7,28 @@
 
 use std::io::{stdin, Read};
 
-use clap::App;
+use clap::Command;
 use uucore::{encoding::Format, error::UResult};
 
 pub mod base_common;
 
-static ABOUT: &str = "
- With no FILE, or when FILE is -, read standard input.
+static ABOUT: &str = "\
+With no FILE, or when FILE is -, read standard input.
 
- The data are encoded as described for the base32 alphabet in RFC
- 4648. When decoding, the input may contain newlines in addition
- to the bytes of the formal base32 alphabet. Use --ignore-garbage
- to attempt to recover from any other non-alphabet bytes in the
- encoded stream.
+The data are encoded as described for the base32 alphabet in RFC
+4648. When decoding, the input may contain newlines in addition
+to the bytes of the formal base32 alphabet. Use --ignore-garbage
+to attempt to recover from any other non-alphabet bytes in the
+encoded stream.
 ";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]", uucore::execution_phrase())
-}
+const USAGE: &str = "{} [OPTION]... [FILE]";
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let format = Format::Base32;
-    let usage = usage();
 
-    let config: base_common::Config = base_common::parse_base_cmd_args(args, ABOUT, &usage)?;
+    let config: base_common::Config = base_common::parse_base_cmd_args(args, ABOUT, USAGE)?;
 
     // Create a reference to stdin so we can return a locked stdin from
     // parse_base_cmd_args
@@ -47,6 +44,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     )
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    base_common::base_app(ABOUT)
+pub fn uu_app<'a>() -> Command<'a> {
+    base_common::base_app(ABOUT, USAGE)
 }
diff --git a/src/uu/base32/src/base_common.rs b/src/uu/base32/src/base_common.rs
index b07203507..100c85b1f 100644
--- a/src/uu/base32/src/base_common.rs
+++ b/src/uu/base32/src/base_common.rs
@@ -12,13 +12,13 @@ use std::io::{stdout, Read, Write};
 use uucore::display::Quotable;
 use uucore::encoding::{wrap_print, Data, Format};
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 use std::fs::File;
 use std::io::{BufReader, Stdin};
 use std::path::Path;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 
 pub static BASE_CMD_PARSE_ERROR: i32 = 1;
 
@@ -38,7 +38,7 @@ pub mod options {
 }
 
 impl Config {
-    pub fn from(options: &clap::ArgMatches) -> UResult<Config> {
+    pub fn from(options: &clap::ArgMatches) -> UResult<Self> {
         let file: Option<String> = match options.values_of(options::FILE) {
             Some(mut values) => {
                 let name = values.next().unwrap();
@@ -76,7 +76,7 @@ impl Config {
             })
             .transpose()?;
 
-        Ok(Config {
+        Ok(Self {
             decode: options.is_present(options::DECODE),
             ignore_garbage: options.is_present(options::IGNORE_GARBAGE),
             wrap_cols: cols,
@@ -86,33 +86,35 @@ impl Config {
 }
 
 pub fn parse_base_cmd_args(args: impl uucore::Args, about: &str, usage: &str) -> UResult<Config> {
-    let app = base_app(about).usage(usage);
+    let command = base_app(about, usage);
     let arg_list = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
-    Config::from(&app.get_matches_from(arg_list))
+    Config::from(&command.get_matches_from(arg_list))
 }
 
-pub fn base_app<'a>(about: &'a str) -> App<'static, 'a> {
-    App::new(uucore::util_name())
+pub fn base_app<'a>(about: &'a str, usage: &'a str) -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(about)
+        .override_usage(format_usage(usage))
+        .infer_long_args(true)
         // Format arguments.
         .arg(
-            Arg::with_name(options::DECODE)
-                .short("d")
+            Arg::new(options::DECODE)
+                .short('d')
                 .long(options::DECODE)
                 .help("decode data"),
         )
         .arg(
-            Arg::with_name(options::IGNORE_GARBAGE)
-                .short("i")
+            Arg::new(options::IGNORE_GARBAGE)
+                .short('i')
                 .long(options::IGNORE_GARBAGE)
                 .help("when decoding, ignore non-alphabetic characters"),
         )
         .arg(
-            Arg::with_name(options::WRAP)
-                .short("w")
+            Arg::new(options::WRAP)
+                .short('w')
                 .long(options::WRAP)
                 .takes_value(true)
                 .help(
@@ -121,7 +123,7 @@ pub fn base_app<'a>(about: &'a str) -> App<'static, 'a> {
         )
         // "multiple" arguments are used to check whether there is more than one
         // file passed in.
-        .arg(Arg::with_name(options::FILE).index(1).multiple(true))
+        .arg(Arg::new(options::FILE).index(1).multiple_occurrences(true))
 }
 
 pub fn get_input<'a>(config: &Config, stdin_ref: &'a Stdin) -> UResult<Box<dyn Read + 'a>> {
@@ -152,7 +154,7 @@ pub fn handle_input<R: Read>(
     if !decode {
         match data.encode() {
             Ok(s) => {
-                wrap_print(&data, s);
+                wrap_print(&data, &s);
                 Ok(())
             }
             Err(_) => Err(USimpleError::new(
diff --git a/src/uu/base32/src/main.rs b/src/uu/base32/src/main.rs
index 83a0b6607..e7ab9a5fd 100644
--- a/src/uu/base32/src/main.rs
+++ b/src/uu/base32/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_base32);
+uucore::bin!(uu_base32);
diff --git a/src/uu/base64/Cargo.toml b/src/uu/base64/Cargo.toml
index c8d71b85a..0169ee77b 100644
--- a/src/uu/base64/Cargo.toml
+++ b/src/uu/base64/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_base64"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "base64 ~ (uutils) decode/encode input (base64-encoding)"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/base64"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/base64"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,9 @@ edition = "2018"
 path = "src/base64.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features = ["encoding"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features = ["encoding"] }
 uu_base32 = { version=">=0.0.8", package="uu_base32", path="../base32"}
 
 [[bin]]
 name = "base64"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/base64/LICENSE b/src/uu/base64/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/base64/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/base64/src/base64.rs b/src/uu/base64/src/base64.rs
index c041d6d69..1bfe29312 100644
--- a/src/uu/base64/src/base64.rs
+++ b/src/uu/base64/src/base64.rs
@@ -13,26 +13,23 @@ use uucore::{encoding::Format, error::UResult};
 
 use std::io::{stdin, Read};
 
-static ABOUT: &str = "
- With no FILE, or when FILE is -, read standard input.
+static ABOUT: &str = "\
+With no FILE, or when FILE is -, read standard input.
 
- The data are encoded as described for the base64 alphabet in RFC
- 3548. When decoding, the input may contain newlines in addition
- to the bytes of the formal base64 alphabet. Use --ignore-garbage
- to attempt to recover from any other non-alphabet bytes in the
- encoded stream.
+The data are encoded as described for the base64 alphabet in RFC
+3548. When decoding, the input may contain newlines in addition
+to the bytes of the formal base64 alphabet. Use --ignore-garbage
+to attempt to recover from any other non-alphabet bytes in the
+encoded stream.
 ";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]", uucore::execution_phrase())
-}
+const USAGE: &str = "{0} [OPTION]... [FILE]";
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let format = Format::Base64;
-    let usage = usage();
 
-    let config: base_common::Config = base_common::parse_base_cmd_args(args, ABOUT, &usage)?;
+    let config: base_common::Config = base_common::parse_base_cmd_args(args, ABOUT, USAGE)?;
 
     // Create a reference to stdin so we can return a locked stdin from
     // parse_base_cmd_args
diff --git a/src/uu/base64/src/main.rs b/src/uu/base64/src/main.rs
index cae6cb3c4..ea5728880 100644
--- a/src/uu/base64/src/main.rs
+++ b/src/uu/base64/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_base64);
+uucore::bin!(uu_base64);
diff --git a/src/uu/basename/Cargo.toml b/src/uu/basename/Cargo.toml
index b75105790..226f61b20 100644
--- a/src/uu/basename/Cargo.toml
+++ b/src/uu/basename/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_basename"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "basename ~ (uutils) display PATHNAME with leading directory components removed"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/basename"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/basename"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/basename.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "basename"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/basename/LICENSE b/src/uu/basename/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/basename/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/basename/src/basename.rs b/src/uu/basename/src/basename.rs
index 464c0e4f1..7b0a0a486 100644
--- a/src/uu/basename/src/basename.rs
+++ b/src/uu/basename/src/basename.rs
@@ -7,23 +7,17 @@
 
 // spell-checker:ignore (ToDO) fullname
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::path::{is_separator, PathBuf};
-use uucore::InvalidEncodingHandling;
+use uucore::display::Quotable;
+use uucore::error::{UResult, UUsageError};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static SUMMARY: &str = "Print NAME with any leading directory components removed
 If specified, also remove a trailing SUFFIX";
 
-fn usage() -> String {
-    format!(
-        "{0} NAME [SUFFIX]
-    {0} OPTION... NAME...",
-        uucore::execution_phrase()
-    )
-}
+const USAGE: &str = "{} NAME [SUFFIX]
+    {} OPTION... NAME...";
 
 pub mod options {
     pub static MULTIPLE: &str = "multiple";
@@ -32,24 +26,19 @@ pub mod options {
     pub static ZERO: &str = "zero";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
-    let usage = usage();
     //
     // Argument parsing
     //
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     // too few arguments
     if !matches.is_present(options::NAME) {
-        crash!(
-            1,
-            "{1}\nTry '{0} --help' for more information.",
-            uucore::execution_phrase(),
-            "missing operand"
-        );
+        return Err(UUsageError::new(1, "missing operand".to_string()));
     }
 
     let opt_suffix = matches.is_present(options::SUFFIX);
@@ -58,12 +47,18 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     let multiple_paths = opt_suffix || opt_multiple;
     // too many arguments
     if !multiple_paths && matches.occurrences_of(options::NAME) > 2 {
-        crash!(
+        return Err(UUsageError::new(
             1,
-            "extra operand '{1}'\nTry '{0} --help' for more information.",
-            uucore::execution_phrase(),
-            matches.values_of(options::NAME).unwrap().nth(2).unwrap()
-        );
+            format!(
+                "extra operand {}",
+                matches
+                    .values_of(options::NAME)
+                    .unwrap()
+                    .nth(2)
+                    .unwrap()
+                    .quote()
+            ),
+        ));
     }
 
     let suffix = if opt_suffix {
@@ -89,30 +84,36 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         print!("{}{}", basename(path, suffix), line_ending);
     }
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(SUMMARY)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::MULTIPLE)
-                .short("a")
+            Arg::new(options::MULTIPLE)
+                .short('a')
                 .long(options::MULTIPLE)
                 .help("support multiple arguments and treat each as a NAME"),
         )
-        .arg(Arg::with_name(options::NAME).multiple(true).hidden(true))
         .arg(
-            Arg::with_name(options::SUFFIX)
-                .short("s")
+            Arg::new(options::NAME)
+                .multiple_occurrences(true)
+                .hide(true),
+        )
+        .arg(
+            Arg::new(options::SUFFIX)
+                .short('s')
                 .long(options::SUFFIX)
                 .value_name("SUFFIX")
                 .help("remove a trailing SUFFIX; implies -a"),
         )
         .arg(
-            Arg::with_name(options::ZERO)
-                .short("z")
+            Arg::new(options::ZERO)
+                .short('z')
                 .long(options::ZERO)
                 .help("end each output line with NUL, not newline"),
         )
@@ -131,21 +132,15 @@ fn basename(fullname: &str, suffix: &str) -> String {
     // Convert to path buffer and get last path component
     let pb = PathBuf::from(path);
     match pb.components().last() {
-        Some(c) => strip_suffix(c.as_os_str().to_str().unwrap(), suffix),
+        Some(c) => {
+            let name = c.as_os_str().to_str().unwrap();
+            if name == suffix {
+                name.to_string()
+            } else {
+                name.strip_suffix(suffix).unwrap_or(name).to_string()
+            }
+        }
+
         None => "".to_owned(),
     }
 }
-
-// can be replaced with strip_suffix once MSRV is 1.45
-#[allow(clippy::manual_strip)]
-fn strip_suffix(name: &str, suffix: &str) -> String {
-    if name == suffix {
-        return name.to_owned();
-    }
-
-    if name.ends_with(suffix) {
-        return name[..name.len() - suffix.len()].to_owned();
-    }
-
-    name.to_owned()
-}
diff --git a/src/uu/basename/src/main.rs b/src/uu/basename/src/main.rs
index aa452f750..68d003269 100644
--- a/src/uu/basename/src/main.rs
+++ b/src/uu/basename/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_basename);
+uucore::bin!(uu_basename);
diff --git a/src/uu/basenc/Cargo.toml b/src/uu/basenc/Cargo.toml
index 165d3d3a0..4242e0391 100644
--- a/src/uu/basenc/Cargo.toml
+++ b/src/uu/basenc/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_basenc"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "basenc ~ (uutils) decode/encode input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/basenc"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/basenc"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,10 @@ edition = "2018"
 path = "src/basenc.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features = ["encoding"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features = ["encoding"] }
 uu_base32 = { version=">=0.0.8", package="uu_base32", path="../base32"}
 
 [[bin]]
 name = "basenc"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/basenc/LICENSE b/src/uu/basenc/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/basenc/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/basenc/src/basenc.rs b/src/uu/basenc/src/basenc.rs
index e4b24c351..d47fe123a 100644
--- a/src/uu/basenc/src/basenc.rs
+++ b/src/uu/basenc/src/basenc.rs
@@ -8,7 +8,7 @@
 
 //spell-checker:ignore (args) lsbf msbf
 
-use clap::{App, Arg};
+use clap::{Arg, Command};
 use uu_base32::base_common::{self, Config, BASE_CMD_PARSE_ERROR};
 
 use uucore::{
@@ -19,12 +19,12 @@ use uucore::{
 
 use std::io::{stdin, Read};
 
-static ABOUT: &str = "
- With no FILE, or when FILE is -, read standard input.
+static ABOUT: &str = "\
+With no FILE, or when FILE is -, read standard input.
 
- When decoding, the input may contain newlines in addition to the bytes of
- the formal alphabet. Use --ignore-garbage to attempt to recover
- from any other non-alphabet bytes in the encoded stream.
+When decoding, the input may contain newlines in addition to the bytes of
+the formal alphabet. Use --ignore-garbage to attempt to recover
+from any other non-alphabet bytes in the encoded stream.
 ";
 
 const ENCODINGS: &[(&str, Format)] = &[
@@ -36,26 +36,20 @@ const ENCODINGS: &[(&str, Format)] = &[
     ("base2lsbf", Format::Base2Lsbf),
     ("base2msbf", Format::Base2Msbf),
     ("z85", Format::Z85),
-    // common abbreviations. TODO: once we have clap 3.0 we can use `AppSettings::InferLongArgs` to get all abbreviations automatically
-    ("base2l", Format::Base2Lsbf),
-    ("base2m", Format::Base2Msbf),
 ];
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]", uucore::execution_phrase())
-}
+const USAGE: &str = "{} [OPTION]... [FILE]";
 
-pub fn uu_app() -> App<'static, 'static> {
-    let mut app = base_common::base_app(ABOUT);
+pub fn uu_app<'a>() -> Command<'a> {
+    let mut command = base_common::base_app(ABOUT, USAGE);
     for encoding in ENCODINGS {
-        app = app.arg(Arg::with_name(encoding.0).long(encoding.0));
+        command = command.arg(Arg::new(encoding.0).long(encoding.0));
     }
-    app
+    command
 }
 
 fn parse_cmd_args(args: impl uucore::Args) -> UResult<(Config, Format)> {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(
+    let matches = uu_app().get_matches_from(
         args.collect_str(InvalidEncodingHandling::ConvertLossy)
             .accept_any(),
     );
@@ -68,7 +62,7 @@ fn parse_cmd_args(args: impl uucore::Args) -> UResult<(Config, Format)> {
     Ok((config, format))
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let (config, format) = parse_cmd_args(args)?;
     // Create a reference to stdin so we can return a locked stdin from
diff --git a/src/uu/basenc/src/main.rs b/src/uu/basenc/src/main.rs
index 9a9a5f4c6..a035e9a68 100644
--- a/src/uu/basenc/src/main.rs
+++ b/src/uu/basenc/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_basenc);
+uucore::bin!(uu_basenc);
diff --git a/src/uu/cat/Cargo.toml b/src/uu/cat/Cargo.toml
index b6b0165ef..f76846491 100644
--- a/src/uu/cat/Cargo.toml
+++ b/src/uu/cat/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_cat"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cat ~ (uutils) concatenate and display input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/cat"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cat"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,18 +15,14 @@ edition = "2018"
 path = "src/cat.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 thiserror = "1.0"
 atty = "0.2"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs", "pipes"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs", "pipes"] }
 
 [target.'cfg(unix)'.dependencies]
 unix_socket = "0.5.0"
-nix = "0.20.0"
-
-[target.'cfg(windows)'.dependencies]
-winapi-util = "0.1.5"
+nix = "0.23.1"
 
 [[bin]]
 name = "cat"
diff --git a/src/uu/cat/LICENSE b/src/uu/cat/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/cat/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/cat/src/cat.rs b/src/uu/cat/src/cat.rs
index af84890db..edba1b8d0 100644
--- a/src/uu/cat/src/cat.rs
+++ b/src/uu/cat/src/cat.rs
@@ -14,12 +14,13 @@
 extern crate unix_socket;
 
 // last synced with: cat (GNU coreutils) 8.13
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::{metadata, File};
 use std::io::{self, Read, Write};
 use thiserror::Error;
 use uucore::display::Quotable;
 use uucore::error::UResult;
+use uucore::fs::FileInformation;
 
 #[cfg(unix)]
 use std::os::unix::io::AsRawFd;
@@ -35,10 +36,10 @@ use std::net::Shutdown;
 use std::os::unix::fs::FileTypeExt;
 #[cfg(unix)]
 use unix_socket::UnixStream;
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static NAME: &str = "cat";
-static SYNTAX: &str = "[OPTION]... [FILE]...";
+static USAGE: &str = "{} [OPTION]... [FILE]...";
 static SUMMARY: &str = "Concatenate FILE(s), or standard input, to standard output
  With no FILE, or when FILE is -, read standard input.";
 
@@ -181,7 +182,7 @@ mod options {
     pub static SHOW_NONPRINTING: &str = "show-nonprinting";
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
@@ -235,67 +236,72 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         show_tabs,
         squeeze_blank,
     };
-    cat_files(files, &options)
+    cat_files(&files, &options)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(SYNTAX)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::SHOW_ALL)
-                .short("A")
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
+        .arg(
+            Arg::new(options::SHOW_ALL)
+                .short('A')
                 .long(options::SHOW_ALL)
                 .help("equivalent to -vET"),
         )
         .arg(
-            Arg::with_name(options::NUMBER_NONBLANK)
-                .short("b")
+            Arg::new(options::NUMBER_NONBLANK)
+                .short('b')
                 .long(options::NUMBER_NONBLANK)
                 .help("number nonempty output lines, overrides -n")
                 .overrides_with(options::NUMBER),
         )
         .arg(
-            Arg::with_name(options::SHOW_NONPRINTING_ENDS)
-                .short("e")
+            Arg::new(options::SHOW_NONPRINTING_ENDS)
+                .short('e')
                 .help("equivalent to -vE"),
         )
         .arg(
-            Arg::with_name(options::SHOW_ENDS)
-                .short("E")
+            Arg::new(options::SHOW_ENDS)
+                .short('E')
                 .long(options::SHOW_ENDS)
                 .help("display $ at end of each line"),
         )
         .arg(
-            Arg::with_name(options::NUMBER)
-                .short("n")
+            Arg::new(options::NUMBER)
+                .short('n')
                 .long(options::NUMBER)
                 .help("number all output lines"),
         )
         .arg(
-            Arg::with_name(options::SQUEEZE_BLANK)
-                .short("s")
+            Arg::new(options::SQUEEZE_BLANK)
+                .short('s')
                 .long(options::SQUEEZE_BLANK)
                 .help("suppress repeated empty output lines"),
         )
         .arg(
-            Arg::with_name(options::SHOW_NONPRINTING_TABS)
-                .short("t")
+            Arg::new(options::SHOW_NONPRINTING_TABS)
+                .short('t')
                 .long(options::SHOW_NONPRINTING_TABS)
                 .help("equivalent to -vT"),
         )
         .arg(
-            Arg::with_name(options::SHOW_TABS)
-                .short("T")
+            Arg::new(options::SHOW_TABS)
+                .short('T')
                 .long(options::SHOW_TABS)
                 .help("display TAB characters at ^I"),
         )
         .arg(
-            Arg::with_name(options::SHOW_NONPRINTING)
-                .short("v")
+            Arg::new(options::SHOW_NONPRINTING)
+                .short('v')
                 .long(options::SHOW_NONPRINTING)
                 .help("use ^ and M- notation, except for LF (\\n) and TAB (\\t)"),
         )
@@ -317,18 +323,17 @@ fn cat_path(
     path: &str,
     options: &OutputOptions,
     state: &mut OutputState,
-    #[cfg(unix)] out_info: &nix::sys::stat::FileStat,
-    #[cfg(windows)] out_info: &winapi_util::file::Information,
+    out_info: Option<&FileInformation>,
 ) -> CatResult<()> {
-    if path == "-" {
-        let stdin = io::stdin();
-        let mut handle = InputHandle {
-            reader: stdin,
-            is_interactive: atty::is(atty::Stream::Stdin),
-        };
-        return cat_handle(&mut handle, options, state);
-    }
     match get_input_type(path)? {
+        InputType::StdIn => {
+            let stdin = io::stdin();
+            let mut handle = InputHandle {
+                reader: stdin,
+                is_interactive: atty::is(atty::Stream::Stdin),
+            };
+            cat_handle(&mut handle, options, state)
+        }
         InputType::Directory => Err(CatError::IsDirectory),
         #[cfg(unix)]
         InputType::Socket => {
@@ -342,10 +347,15 @@ fn cat_path(
         }
         _ => {
             let file = File::open(path)?;
-            #[cfg(any(windows, unix))]
-            if same_file(out_info, &file) {
-                return Err(CatError::OutputIsInput);
+
+            if let Some(out_info) = out_info {
+                if out_info.file_size() != 0
+                    && FileInformation::from_file(&file).as_ref() == Some(out_info)
+                {
+                    return Err(CatError::OutputIsInput);
+                }
             }
+
             let mut handle = InputHandle {
                 reader: file,
                 is_interactive: false,
@@ -355,25 +365,8 @@ fn cat_path(
     }
 }
 
-#[cfg(unix)]
-fn same_file(a_info: &nix::sys::stat::FileStat, b: &File) -> bool {
-    let b_info = nix::sys::stat::fstat(b.as_raw_fd()).unwrap();
-    b_info.st_size != 0 && b_info.st_dev == a_info.st_dev && b_info.st_ino == a_info.st_ino
-}
-
-#[cfg(windows)]
-fn same_file(a_info: &winapi_util::file::Information, b: &File) -> bool {
-    let b_info = winapi_util::file::information(b).unwrap();
-    b_info.file_size() != 0
-        && b_info.volume_serial_number() == a_info.volume_serial_number()
-        && b_info.file_index() == a_info.file_index()
-}
-
-fn cat_files(files: Vec<String>, options: &OutputOptions) -> UResult<()> {
-    #[cfg(windows)]
-    let out_info = winapi_util::file::information(&std::io::stdout()).unwrap();
-    #[cfg(unix)]
-    let out_info = nix::sys::stat::fstat(std::io::stdout().as_raw_fd()).unwrap();
+fn cat_files(files: &[String], options: &OutputOptions) -> UResult<()> {
+    let out_info = FileInformation::from_file(&std::io::stdout());
 
     let mut state = OutputState {
         line_number: 1,
@@ -383,8 +376,8 @@ fn cat_files(files: Vec<String>, options: &OutputOptions) -> UResult<()> {
     };
     let mut error_messages: Vec<String> = Vec::new();
 
-    for path in &files {
-        if let Err(err) = cat_path(path, options, &mut state, &out_info) {
+    for path in files {
+        if let Err(err) = cat_path(path, options, &mut state, out_info.as_ref()) {
             error_messages.push(format!("{}: {}", path.maybe_quote(), err));
         }
     }
@@ -486,7 +479,7 @@ fn write_lines<R: FdReadable>(
                 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!(&mut writer, "{0:6}\t", state.line_number)?;
+                        write!(writer, "{0:6}\t", state.line_number)?;
                         state.line_number += 1;
                     }
                     writer.write_all(options.end_of_line().as_bytes())?;
@@ -505,7 +498,7 @@ fn write_lines<R: FdReadable>(
             }
             state.one_blank_kept = false;
             if state.at_line_start && options.number != NumberingMode::None {
-                write!(&mut writer, "{0:6}\t", state.line_number)?;
+                write!(writer, "{0:6}\t", state.line_number)?;
                 state.line_number += 1;
             }
 
@@ -567,13 +560,12 @@ fn write_tab_to_end<W: Write>(mut in_buf: &[u8], writer: &mut W) -> usize {
         {
             Some(p) => {
                 writer.write_all(&in_buf[..p]).unwrap();
-                if in_buf[p] == b'\n' {
-                    return count + p;
-                } else if in_buf[p] == b'\t' {
+                if in_buf[p] == b'\t' {
                     writer.write_all(b"^I").unwrap();
                     in_buf = &in_buf[p + 1..];
                     count += p + 1;
                 } else {
+                    // b'\n' or b'\r'
                     return count + p;
                 }
             }
@@ -596,10 +588,10 @@ fn write_nonprint_to_end<W: Write>(in_buf: &[u8], writer: &mut W, tab: &[u8]) ->
             9 => writer.write_all(tab),
             0..=8 | 10..=31 => writer.write_all(&[b'^', byte + 64]),
             32..=126 => writer.write_all(&[byte]),
-            127 => writer.write_all(&[b'^', byte - 64]),
+            127 => writer.write_all(&[b'^', b'?']),
             128..=159 => writer.write_all(&[b'M', b'-', b'^', byte - 64]),
             160..=254 => writer.write_all(&[b'M', b'-', byte - 128]),
-            _ => writer.write_all(&[b'M', b'-', b'^', 63]),
+            _ => writer.write_all(&[b'M', b'-', b'^', b'?']),
         }
         .unwrap();
         count += 1;
diff --git a/src/uu/cat/src/main.rs b/src/uu/cat/src/main.rs
index 1adab666b..df198c960 100644
--- a/src/uu/cat/src/main.rs
+++ b/src/uu/cat/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_cat);
+uucore::bin!(uu_cat);
diff --git a/src/uu/chcon/Cargo.toml b/src/uu/chcon/Cargo.toml
index a359f142f..092f7702e 100644
--- a/src/uu/chcon/Cargo.toml
+++ b/src/uu/chcon/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
 name = "uu_chcon"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chcon ~ (uutils) change file security context"
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/chcon"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chcon"
 keywords = ["coreutils", "uutils", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -14,9 +14,8 @@ edition = "2018"
 path = "src/chcon.rs"
 
 [dependencies]
-clap         = { version = "2.33", features = ["wrap_help"] }
+clap         = { version = "3.1", features = ["wrap_help", "cargo"] }
 uucore       = { version = ">=0.0.9", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
-uucore_procs = { version = ">=0.0.6", package="uucore_procs", path="../../uucore_procs" }
 selinux      = { version = "0.2"   }
 fts-sys      = { version = "0.2"   }
 thiserror    = { version = "1.0"   }
diff --git a/src/uu/chcon/LICENSE b/src/uu/chcon/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/chcon/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/chcon/src/chcon.rs b/src/uu/chcon/src/chcon.rs
index 9664f69f5..e49191ea3 100644
--- a/src/uu/chcon/src/chcon.rs
+++ b/src/uu/chcon/src/chcon.rs
@@ -2,9 +2,11 @@
 
 #![allow(clippy::upper_case_acronyms)]
 
-use uucore::{display::Quotable, show_error, show_usage_error, show_warning};
+use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::format_usage;
+use uucore::{display::Quotable, show_error, show_warning};
 
-use clap::{App, Arg};
+use clap::{Arg, Command};
 use selinux::{OpaqueSecurityContext, SecurityContext};
 
 use std::borrow::Cow;
@@ -21,8 +23,13 @@ use errors::*;
 static VERSION: &str = env!("CARGO_PKG_VERSION");
 static ABOUT: &str = "Change the SELinux security context of each FILE to CONTEXT. \n\
                       With --reference, change the security context of each FILE to that of RFILE.";
+const USAGE: &str = "\
+    {} [OPTION]... CONTEXT FILE... \n    \
+    {} [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE... \n    \
+    {} [OPTION]... --reference=RFILE FILE...";
 
 pub mod options {
+    pub static HELP: &str = "help";
     pub static VERBOSE: &str = "verbose";
 
     pub static REFERENCE: &str = "reference";
@@ -51,35 +58,24 @@ pub mod options {
     }
 }
 
-fn get_usage() -> String {
-    format!(
-        "{0} [OPTION]... CONTEXT FILE... \n    \
-         {0} [OPTION]... [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE... \n    \
-         {0} [OPTION]... --reference=RFILE FILE...",
-        uucore::execution_phrase()
-    )
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = get_usage();
-
-    let config = uu_app().usage(usage.as_ref());
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let config = uu_app();
 
     let options = match parse_command_line(config, args) {
         Ok(r) => r,
         Err(r) => {
             if let Error::CommandLine(r) = &r {
-                match r.kind {
-                    clap::ErrorKind::HelpDisplayed | clap::ErrorKind::VersionDisplayed => {
+                match r.kind() {
+                    clap::ErrorKind::DisplayHelp | clap::ErrorKind::DisplayVersion => {
                         println!("{}", r);
-                        return libc::EXIT_SUCCESS;
+                        return Ok(());
                     }
                     _ => {}
                 }
             }
 
-            show_usage_error!("{}.\n", r);
-            return libc::EXIT_FAILURE;
+            return Err(UUsageError::new(libc::EXIT_FAILURE, format!("{}.\n", r)));
         }
     };
 
@@ -98,8 +94,10 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
             match result {
                 Err(r) => {
-                    show_error!("{}.", report_full_error(&r));
-                    return libc::EXIT_FAILURE;
+                    return Err(USimpleError::new(
+                        libc::EXIT_FAILURE,
+                        format!("{}.", report_full_error(&r)),
+                    ));
                 }
 
                 Ok(file_context) => SELinuxSecurityContext::File(file_context),
@@ -111,14 +109,18 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                 Ok(context) => context,
 
                 Err(_r) => {
-                    show_error!("Invalid security context {}.", context.quote());
-                    return libc::EXIT_FAILURE;
+                    return Err(USimpleError::new(
+                        libc::EXIT_FAILURE,
+                        format!("Invalid security context {}.", context.quote()),
+                    ));
                 }
             };
 
             if SecurityContext::from_c_str(&c_context, false).check() == Some(false) {
-                show_error!("Invalid security context {}.", context.quote());
-                return libc::EXIT_FAILURE;
+                return Err(USimpleError::new(
+                    libc::EXIT_FAILURE,
+                    format!("Invalid security context {}.", context.quote()),
+                ));
             }
 
             SELinuxSecurityContext::String(Some(c_context))
@@ -132,8 +134,10 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             Ok(r) => Some(r),
 
             Err(r) => {
-                show_error!("{}.", report_full_error(&r));
-                return libc::EXIT_FAILURE;
+                return Err(USimpleError::new(
+                    libc::EXIT_FAILURE,
+                    format!("{}.", report_full_error(&r)),
+                ));
             }
         }
     } else {
@@ -142,21 +146,28 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     let results = process_files(&options, &context, root_dev_ino);
     if results.is_empty() {
-        return libc::EXIT_SUCCESS;
+        return Ok(());
     }
 
     for result in &results {
         show_error!("{}.", report_full_error(result));
     }
-    libc::EXIT_FAILURE
+    Err(libc::EXIT_FAILURE.into())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(VERSION)
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::dereference::DEREFERENCE)
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information."),
+        )
+        .arg(
+            Arg::new(options::dereference::DEREFERENCE)
                 .long(options::dereference::DEREFERENCE)
                 .conflicts_with(options::dereference::NO_DEREFERENCE)
                 .help(
@@ -165,24 +176,24 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::dereference::NO_DEREFERENCE)
-                .short("h")
+            Arg::new(options::dereference::NO_DEREFERENCE)
+                .short('h')
                 .long(options::dereference::NO_DEREFERENCE)
                 .help("Affect symbolic links instead of any referenced file."),
         )
         .arg(
-            Arg::with_name(options::preserve_root::PRESERVE_ROOT)
+            Arg::new(options::preserve_root::PRESERVE_ROOT)
                 .long(options::preserve_root::PRESERVE_ROOT)
                 .conflicts_with(options::preserve_root::NO_PRESERVE_ROOT)
                 .help("Fail to operate recursively on '/'."),
         )
         .arg(
-            Arg::with_name(options::preserve_root::NO_PRESERVE_ROOT)
+            Arg::new(options::preserve_root::NO_PRESERVE_ROOT)
                 .long(options::preserve_root::NO_PRESERVE_ROOT)
                 .help("Do not treat '/' specially (the default)."),
         )
         .arg(
-            Arg::with_name(options::REFERENCE)
+            Arg::new(options::REFERENCE)
                 .long(options::REFERENCE)
                 .takes_value(true)
                 .value_name("RFILE")
@@ -190,49 +201,54 @@ pub fn uu_app() -> App<'static, 'static> {
                 .help(
                     "Use security context of RFILE, rather than specifying \
                      a CONTEXT value.",
-                ),
+                )
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::USER)
-                .short("u")
+            Arg::new(options::USER)
+                .short('u')
                 .long(options::USER)
                 .takes_value(true)
                 .value_name("USER")
-                .help("Set user USER in the target security context."),
+                .help("Set user USER in the target security context.")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::ROLE)
-                .short("r")
+            Arg::new(options::ROLE)
+                .short('r')
                 .long(options::ROLE)
                 .takes_value(true)
                 .value_name("ROLE")
-                .help("Set role ROLE in the target security context."),
+                .help("Set role ROLE in the target security context.")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::TYPE)
-                .short("t")
+            Arg::new(options::TYPE)
+                .short('t')
                 .long(options::TYPE)
                 .takes_value(true)
                 .value_name("TYPE")
-                .help("Set type TYPE in the target security context."),
+                .help("Set type TYPE in the target security context.")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::RANGE)
-                .short("l")
+            Arg::new(options::RANGE)
+                .short('l')
                 .long(options::RANGE)
                 .takes_value(true)
                 .value_name("RANGE")
-                .help("Set range RANGE in the target security context."),
+                .help("Set range RANGE in the target security context.")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::RECURSIVE)
-                .short("R")
+            Arg::new(options::RECURSIVE)
+                .short('R')
                 .long(options::RECURSIVE)
                 .help("Operate on files and directories recursively."),
         )
         .arg(
-            Arg::with_name(options::sym_links::FOLLOW_ARG_DIR_SYM_LINK)
-                .short("H")
+            Arg::new(options::sym_links::FOLLOW_ARG_DIR_SYM_LINK)
+                .short('H')
                 .requires(options::RECURSIVE)
                 .overrides_with_all(&[
                     options::sym_links::FOLLOW_DIR_SYM_LINKS,
@@ -244,8 +260,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::sym_links::FOLLOW_DIR_SYM_LINKS)
-                .short("L")
+            Arg::new(options::sym_links::FOLLOW_DIR_SYM_LINKS)
+                .short('L')
                 .requires(options::RECURSIVE)
                 .overrides_with_all(&[
                     options::sym_links::FOLLOW_ARG_DIR_SYM_LINK,
@@ -257,8 +273,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::sym_links::NO_FOLLOW_SYM_LINKS)
-                .short("P")
+            Arg::new(options::sym_links::NO_FOLLOW_SYM_LINKS)
+                .short('P')
                 .requires(options::RECURSIVE)
                 .overrides_with_all(&[
                     options::sym_links::FOLLOW_ARG_DIR_SYM_LINK,
@@ -270,12 +286,17 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::VERBOSE)
-                .short("v")
+            Arg::new(options::VERBOSE)
+                .short('v')
                 .long(options::VERBOSE)
                 .help("Output a diagnostic for every file processed."),
         )
-        .arg(Arg::with_name("FILE").multiple(true).min_values(1))
+        .arg(
+            Arg::new("FILE")
+                .multiple_occurrences(true)
+                .min_values(1)
+                .allow_invalid_utf8(true),
+        )
 }
 
 #[derive(Debug)]
@@ -288,8 +309,8 @@ struct Options {
     files: Vec<PathBuf>,
 }
 
-fn parse_command_line(config: clap::App, args: impl uucore::Args) -> Result<Options> {
-    let matches = config.get_matches_from_safe(args)?;
+fn parse_command_line(config: clap::Command, args: impl uucore::Args) -> Result<Options> {
+    let matches = config.try_get_matches_from(args)?;
 
     let verbose = matches.is_present(options::VERBOSE);
 
@@ -387,23 +408,21 @@ enum RecursiveMode {
 impl RecursiveMode {
     fn is_recursive(self) -> bool {
         match self {
-            RecursiveMode::NotRecursive => false,
+            Self::NotRecursive => false,
 
-            RecursiveMode::RecursiveButDoNotFollowSymLinks
-            | RecursiveMode::RecursiveAndFollowAllDirSymLinks
-            | RecursiveMode::RecursiveAndFollowArgDirSymLinks => true,
+            Self::RecursiveButDoNotFollowSymLinks
+            | Self::RecursiveAndFollowAllDirSymLinks
+            | Self::RecursiveAndFollowArgDirSymLinks => true,
         }
     }
 
     fn fts_open_options(self) -> c_int {
         match self {
-            RecursiveMode::NotRecursive | RecursiveMode::RecursiveButDoNotFollowSymLinks => {
-                fts_sys::FTS_PHYSICAL
-            }
+            Self::NotRecursive | Self::RecursiveButDoNotFollowSymLinks => fts_sys::FTS_PHYSICAL,
 
-            RecursiveMode::RecursiveAndFollowAllDirSymLinks => fts_sys::FTS_LOGICAL,
+            Self::RecursiveAndFollowAllDirSymLinks => fts_sys::FTS_LOGICAL,
 
-            RecursiveMode::RecursiveAndFollowArgDirSymLinks => {
+            Self::RecursiveAndFollowArgDirSymLinks => {
                 fts_sys::FTS_PHYSICAL | fts_sys::FTS_COMFOLLOW
             }
         }
@@ -707,7 +726,7 @@ fn root_dev_ino_warn(dir_name: &Path) {
 // When a program like chgrp performs a recursive traversal that requires traversing symbolic links,
 // it is *not* a problem.
 // However, when invoked with "-P -R", it deserves a warning.
-// The fts_options parameter records the options that control this aspect of fts's behavior,
+// The fts_options parameter records the options that control this aspect of fts behavior,
 // so test that.
 fn cycle_warning_required(fts_options: c_int, entry: &fts::EntryRef) -> bool {
     // When dereferencing no symlinks, or when dereferencing only those listed on the command line
@@ -723,7 +742,7 @@ This almost certainly means that you have a corrupted file system.\n\
 NOTIFY YOUR SYSTEM MANAGER.\n\
 The following directory is part of the cycle {}.",
         file_name.quote()
-    )
+    );
 }
 
 #[derive(Debug)]
diff --git a/src/uu/chcon/src/errors.rs b/src/uu/chcon/src/errors.rs
index 2d8f72e67..8a1678a85 100644
--- a/src/uu/chcon/src/errors.rs
+++ b/src/uu/chcon/src/errors.rs
@@ -64,10 +64,10 @@ impl Error {
 
 pub(crate) fn report_full_error(mut err: &dyn std::error::Error) -> String {
     let mut desc = String::with_capacity(256);
-    write!(&mut desc, "{}", err).unwrap();
+    write!(desc, "{}", err).unwrap();
     while let Some(source) = err.source() {
         err = source;
-        write!(&mut desc, ". {}", err).unwrap();
+        write!(desc, ". {}", err).unwrap();
     }
     desc
 }
diff --git a/src/uu/chcon/src/main.rs b/src/uu/chcon/src/main.rs
index e23b34c5b..d93d7d1da 100644
--- a/src/uu/chcon/src/main.rs
+++ b/src/uu/chcon/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_chcon);
+uucore::bin!(uu_chcon);
diff --git a/src/uu/chgrp/Cargo.toml b/src/uu/chgrp/Cargo.toml
index acc03472c..952c83e54 100644
--- a/src/uu/chgrp/Cargo.toml
+++ b/src/uu/chgrp/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_chgrp"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chgrp ~ (uutils) change the group ownership of FILE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/chgrp"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chgrp"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/chgrp.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
 
 [[bin]]
 name = "chgrp"
diff --git a/src/uu/chgrp/LICENSE b/src/uu/chgrp/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/chgrp/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/chgrp/src/chgrp.rs b/src/uu/chgrp/src/chgrp.rs
index c70e5e5c7..d7e8baafe 100644
--- a/src/uu/chgrp/src/chgrp.rs
+++ b/src/uu/chgrp/src/chgrp.rs
@@ -10,9 +10,10 @@
 use uucore::display::Quotable;
 pub use uucore::entries;
 use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::format_usage;
 use uucore::perms::{chown_base, options, IfFrom};
 
-use clap::{App, Arg, ArgMatches};
+use clap::{Arg, ArgMatches, Command};
 
 use std::fs;
 use std::os::unix::fs::MetadataExt;
@@ -20,12 +21,9 @@ use std::os::unix::fs::MetadataExt;
 static ABOUT: &str = "Change the group of each FILE to GROUP.";
 static VERSION: &str = env!("CARGO_PKG_VERSION");
 
-fn get_usage() -> String {
-    format!(
-        "{0} [OPTION]... GROUP FILE...\n    {0} [OPTION]... --reference=RFILE FILE...",
-        uucore::execution_phrase()
-    )
-}
+const USAGE: &str = "\
+    {} [OPTION]... GROUP FILE...\n    \
+    {} [OPTION]... --reference=RFILE FILE...";
 
 fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)> {
     let dest_gid = if let Some(file) = matches.value_of(options::REFERENCE) {
@@ -51,95 +49,94 @@ fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>,
     Ok((dest_gid, None, IfFrom::All))
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = get_usage();
-
-    chown_base(
-        uu_app().usage(&usage[..]),
-        args,
-        options::ARG_GROUP,
-        parse_gid_and_uid,
-        true,
-    )
+    chown_base(uu_app(), args, options::ARG_GROUP, parse_gid_and_uid, true)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(VERSION)
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::verbosity::CHANGES)
-                .short("c")
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information.")
+        )
+        .arg(
+            Arg::new(options::verbosity::CHANGES)
+                .short('c')
                 .long(options::verbosity::CHANGES)
                 .help("like verbose but report only when a change is made"),
         )
         .arg(
-            Arg::with_name(options::verbosity::SILENT)
-                .short("f")
+            Arg::new(options::verbosity::SILENT)
+                .short('f')
                 .long(options::verbosity::SILENT),
         )
         .arg(
-            Arg::with_name(options::verbosity::QUIET)
+            Arg::new(options::verbosity::QUIET)
                 .long(options::verbosity::QUIET)
                 .help("suppress most error messages"),
         )
         .arg(
-            Arg::with_name(options::verbosity::VERBOSE)
-                .short("v")
+            Arg::new(options::verbosity::VERBOSE)
+                .short('v')
                 .long(options::verbosity::VERBOSE)
                 .help("output a diagnostic for every file processed"),
         )
         .arg(
-            Arg::with_name(options::dereference::DEREFERENCE)
+            Arg::new(options::dereference::DEREFERENCE)
                 .long(options::dereference::DEREFERENCE),
         )
         .arg(
-           Arg::with_name(options::dereference::NO_DEREFERENCE)
-               .short("h")
+           Arg::new(options::dereference::NO_DEREFERENCE)
+               .short('h')
                .long(options::dereference::NO_DEREFERENCE)
                .help(
                    "affect symbolic links instead of any referenced file (useful only on systems that can change the ownership of a symlink)",
                ),
         )
         .arg(
-            Arg::with_name(options::preserve_root::PRESERVE)
+            Arg::new(options::preserve_root::PRESERVE)
                 .long(options::preserve_root::PRESERVE)
                 .help("fail to operate recursively on '/'"),
         )
         .arg(
-            Arg::with_name(options::preserve_root::NO_PRESERVE)
+            Arg::new(options::preserve_root::NO_PRESERVE)
                 .long(options::preserve_root::NO_PRESERVE)
                 .help("do not treat '/' specially (the default)"),
         )
         .arg(
-            Arg::with_name(options::REFERENCE)
+            Arg::new(options::REFERENCE)
                 .long(options::REFERENCE)
                 .value_name("RFILE")
                 .help("use RFILE's group rather than specifying GROUP values")
                 .takes_value(true)
-                .multiple(false),
+                .multiple_occurrences(false),
         )
         .arg(
-            Arg::with_name(options::RECURSIVE)
-                .short("R")
+            Arg::new(options::RECURSIVE)
+                .short('R')
                 .long(options::RECURSIVE)
                 .help("operate on files and directories recursively"),
         )
         .arg(
-            Arg::with_name(options::traverse::TRAVERSE)
-                .short(options::traverse::TRAVERSE)
+            Arg::new(options::traverse::TRAVERSE)
+                .short(options::traverse::TRAVERSE.chars().next().unwrap())
                 .help("if a command line argument is a symbolic link to a directory, traverse it"),
         )
         .arg(
-            Arg::with_name(options::traverse::NO_TRAVERSE)
-                .short(options::traverse::NO_TRAVERSE)
+            Arg::new(options::traverse::NO_TRAVERSE)
+                .short(options::traverse::NO_TRAVERSE.chars().next().unwrap())
                 .help("do not traverse any symbolic links (default)")
                 .overrides_with_all(&[options::traverse::TRAVERSE, options::traverse::EVERY]),
         )
         .arg(
-            Arg::with_name(options::traverse::EVERY)
-                .short(options::traverse::EVERY)
+            Arg::new(options::traverse::EVERY)
+                .short(options::traverse::EVERY.chars().next().unwrap())
                 .help("traverse every symbolic link to a directory encountered"),
         )
 }
diff --git a/src/uu/chgrp/src/main.rs b/src/uu/chgrp/src/main.rs
index ee6f70a8b..7d5330a61 100644
--- a/src/uu/chgrp/src/main.rs
+++ b/src/uu/chgrp/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_chgrp);
+uucore::bin!(uu_chgrp);
diff --git a/src/uu/chmod/Cargo.toml b/src/uu/chmod/Cargo.toml
index 64961e6dd..844c65544 100644
--- a/src/uu/chmod/Cargo.toml
+++ b/src/uu/chmod/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_chmod"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chmod ~ (uutils) change mode of FILE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/chmod"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chmod"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,9 @@ edition = "2018"
 path = "src/chmod.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs", "mode"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-walkdir = "2.2"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs", "mode"] }
 
 [[bin]]
 name = "chmod"
diff --git a/src/uu/chmod/LICENSE b/src/uu/chmod/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/chmod/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/chmod/src/chmod.rs b/src/uu/chmod/src/chmod.rs
index 68c55b4cb..25a37c372 100644
--- a/src/uu/chmod/src/chmod.rs
+++ b/src/uu/chmod/src/chmod.rs
@@ -7,20 +7,17 @@
 
 // spell-checker:ignore (ToDO) Chmoder cmode fmode fperm fref ugoa RFILE RFILE's
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs;
 use std::os::unix::fs::{MetadataExt, PermissionsExt};
 use std::path::Path;
 use uucore::display::Quotable;
+use uucore::error::{ExitCode, UResult, USimpleError, UUsageError};
 use uucore::fs::display_permissions_unix;
 use uucore::libc::mode_t;
 #[cfg(not(windows))]
 use uucore::mode;
-use uucore::InvalidEncodingHandling;
-use walkdir::WalkDir;
+use uucore::{format_usage, show_error, InvalidEncodingHandling};
 
 static ABOUT: &str = "Change the mode of each FILE to MODE.
  With --reference, change the mode of each FILE to that of RFILE.";
@@ -37,20 +34,17 @@ mod options {
     pub const FILE: &str = "FILE";
 }
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... MODE[,MODE]... FILE...
-or: {0} [OPTION]... OCTAL-MODE FILE...
-or: {0} [OPTION]... --reference=RFILE FILE...",
-        uucore::execution_phrase()
-    )
-}
+const USAGE: &str = "\
+    {} [OPTION]... MODE[,MODE]... FILE...
+    {} [OPTION]... OCTAL-MODE FILE...
+    {} [OPTION]... --reference=RFILE FILE...";
 
 fn get_long_usage() -> String {
     String::from("Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.")
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let mut args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -59,25 +53,27 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     // a possible MODE prefix '-' needs to be removed (e.g. "chmod -x FILE").
     let mode_had_minus_prefix = mode::strip_minus_from_mode(&mut args);
 
-    let usage = usage();
     let after_help = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let changes = matches.is_present(options::CHANGES);
     let quiet = matches.is_present(options::QUIET);
     let verbose = matches.is_present(options::VERBOSE);
     let preserve_root = matches.is_present(options::PRESERVE_ROOT);
     let recursive = matches.is_present(options::RECURSIVE);
-    let fmode = matches
-        .value_of(options::REFERENCE)
-        .and_then(|fref| match fs::metadata(fref) {
+    let fmode = match matches.value_of(options::REFERENCE) {
+        Some(fref) => match fs::metadata(fref) {
             Ok(meta) => Some(meta.mode()),
-            Err(err) => crash!(1, "cannot stat attributes of {}: {}", fref.quote(), err),
-        });
+            Err(err) => {
+                return Err(USimpleError::new(
+                    1,
+                    format!("cannot stat attributes of {}: {}", fref.quote(), err),
+                ))
+            }
+        },
+        None => None,
+    };
     let modes = matches.value_of(options::MODE).unwrap(); // should always be Some because required
     let cmode = if mode_had_minus_prefix {
         // clap parsing is finished, now put prefix back
@@ -100,7 +96,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     };
 
     if files.is_empty() {
-        crash!(1, "missing operand");
+        return Err(UUsageError::new(1, "missing operand".to_string()));
     }
 
     let chmoder = Chmoder {
@@ -112,71 +108,69 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         fmode,
         cmode,
     };
-    match chmoder.chmod(files) {
-        Ok(()) => {}
-        Err(e) => return e,
-    }
 
-    0
+    chmoder.chmod(&files)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::CHANGES)
+            Arg::new(options::CHANGES)
                 .long(options::CHANGES)
-                .short("c")
+                .short('c')
                 .help("like verbose but report only when a change is made"),
         )
         .arg(
-            Arg::with_name(options::QUIET)
+            Arg::new(options::QUIET)
                 .long(options::QUIET)
                 .visible_alias("silent")
-                .short("f")
+                .short('f')
                 .help("suppress most error messages"),
         )
         .arg(
-            Arg::with_name(options::VERBOSE)
+            Arg::new(options::VERBOSE)
                 .long(options::VERBOSE)
-                .short("v")
+                .short('v')
                 .help("output a diagnostic for every file processed"),
         )
         .arg(
-            Arg::with_name(options::NO_PRESERVE_ROOT)
+            Arg::new(options::NO_PRESERVE_ROOT)
                 .long(options::NO_PRESERVE_ROOT)
                 .help("do not treat '/' specially (the default)"),
         )
         .arg(
-            Arg::with_name(options::PRESERVE_ROOT)
+            Arg::new(options::PRESERVE_ROOT)
                 .long(options::PRESERVE_ROOT)
                 .help("fail to operate recursively on '/'"),
         )
         .arg(
-            Arg::with_name(options::RECURSIVE)
+            Arg::new(options::RECURSIVE)
                 .long(options::RECURSIVE)
-                .short("R")
+                .short('R')
                 .help("change files and directories recursively"),
         )
         .arg(
-            Arg::with_name(options::REFERENCE)
+            Arg::new(options::REFERENCE)
                 .long("reference")
                 .takes_value(true)
                 .help("use RFILE's mode instead of MODE values"),
         )
         .arg(
-            Arg::with_name(options::MODE)
-                .required_unless(options::REFERENCE)
+            Arg::new(options::MODE)
+                .required_unless_present(options::REFERENCE)
                 .takes_value(true),
             // It would be nice if clap could parse with delimiter, e.g. "g-x,u+x",
-            // however .multiple(true) cannot be used here because FILE already needs that.
-            // Only one positional argument with .multiple(true) set is allowed per command
+            // however .multiple_occurrences(true) cannot be used here because FILE already needs that.
+            // Only one positional argument with .multiple_occurrences(true) set is allowed per command
         )
         .arg(
-            Arg::with_name(options::FILE)
-                .required_unless(options::MODE)
-                .multiple(true),
+            Arg::new(options::FILE)
+                .required_unless_present(options::MODE)
+                .multiple_occurrences(true),
         )
 }
 
@@ -191,10 +185,10 @@ struct Chmoder {
 }
 
 impl Chmoder {
-    fn chmod(&self, files: Vec<String>) -> Result<(), i32> {
+    fn chmod(&self, files: &[String]) -> UResult<()> {
         let mut r = Ok(());
 
-        for filename in &files {
+        for filename in files {
             let filename = &filename[..];
             let file = Path::new(filename);
             if !file.exists() {
@@ -204,29 +198,47 @@ impl Chmoder {
                         filename.quote()
                     );
                     if !self.quiet {
-                        show_error!("cannot operate on dangling symlink {}", filename.quote());
+                        return Err(USimpleError::new(
+                            1,
+                            format!("cannot operate on dangling symlink {}", filename.quote()),
+                        ));
                     }
                 } else if !self.quiet {
-                    show_error!(
-                        "cannot access {}: No such file or directory",
-                        filename.quote()
-                    );
+                    return Err(USimpleError::new(
+                        1,
+                        format!(
+                            "cannot access {}: No such file or directory",
+                            filename.quote()
+                        ),
+                    ));
                 }
-                return Err(1);
+                return Err(ExitCode::new(1));
             }
             if self.recursive && self.preserve_root && filename == "/" {
-                show_error!(
-                    "it is dangerous to operate recursively on {}\nuse --no-preserve-root to override this failsafe",
-                    filename.quote()
-                );
-                return Err(1);
+                return Err(USimpleError::new(
+                    1,
+                    format!(
+                        "it is dangerous to operate recursively on {}\nuse --no-preserve-root to override this failsafe",
+                        filename.quote()
+                    )
+                ));
             }
             if !self.recursive {
                 r = self.chmod_file(file).and(r);
             } else {
-                for entry in WalkDir::new(&filename).into_iter().filter_map(|e| e.ok()) {
-                    let file = entry.path();
-                    r = self.chmod_file(file).and(r);
+                r = self.walk_dir(file);
+            }
+        }
+        r
+    }
+
+    fn walk_dir(&self, file_path: &Path) -> UResult<()> {
+        let mut r = self.chmod_file(file_path);
+        if !is_symlink(file_path) && file_path.is_dir() {
+            for dir_entry in file_path.read_dir()? {
+                let path = dir_entry?.path();
+                if !is_symlink(&path) {
+                    r = self.walk_dir(path.as_path());
                 }
             }
         }
@@ -234,14 +246,14 @@ impl Chmoder {
     }
 
     #[cfg(windows)]
-    fn chmod_file(&self, file: &Path) -> Result<(), i32> {
+    fn chmod_file(&self, file: &Path) -> UResult<()> {
         // chmod is useless on Windows
         // it doesn't set any permissions at all
         // instead it just sets the readonly attribute on the file
-        Err(0)
+        Ok(())
     }
     #[cfg(unix)]
-    fn chmod_file(&self, file: &Path) -> Result<(), i32> {
+    fn chmod_file(&self, file: &Path) -> UResult<()> {
         use uucore::mode::get_umask;
 
         let fperm = match fs::metadata(file) {
@@ -258,11 +270,13 @@ impl Chmoder {
                 } else if err.kind() == std::io::ErrorKind::PermissionDenied {
                     // These two filenames would normally be conditionally
                     // quoted, but GNU's tests expect them to always be quoted
-                    show_error!("{}: Permission denied", file.quote());
+                    return Err(USimpleError::new(
+                        1,
+                        format!("{}: Permission denied", file.quote()),
+                    ));
                 } else {
-                    show_error!("{}: {}", file.quote(), err);
+                    return Err(USimpleError::new(1, format!("{}: {}", file.quote(), err)));
                 }
-                return Err(1);
             }
         };
         match self.fmode {
@@ -296,22 +310,25 @@ impl Chmoder {
                         }
                         Err(f) => {
                             if !self.quiet {
-                                show_error!("{}", f);
+                                return Err(USimpleError::new(1, f));
+                            } else {
+                                return Err(ExitCode::new(1));
                             }
-                            return Err(1);
                         }
                     }
                 }
                 self.change_file(fperm, new_mode, file)?;
                 // if a permission would have been removed if umask was 0, but it wasn't because umask was not 0, print an error and fail
                 if (new_mode & !naively_expected_new_mode) != 0 {
-                    show_error!(
-                        "{}: new permissions are {}, not {}",
-                        file.maybe_quote(),
-                        display_permissions_unix(new_mode as mode_t, false),
-                        display_permissions_unix(naively_expected_new_mode as mode_t, false)
-                    );
-                    return Err(1);
+                    return Err(USimpleError::new(
+                        1,
+                        format!(
+                            "{}: new permissions are {}, not {}",
+                            file.maybe_quote(),
+                            display_permissions_unix(new_mode as mode_t, false),
+                            display_permissions_unix(naively_expected_new_mode as mode_t, false)
+                        ),
+                    ));
                 }
             }
         }
diff --git a/src/uu/chmod/src/main.rs b/src/uu/chmod/src/main.rs
index adaf887f8..f0ec0c2e9 100644
--- a/src/uu/chmod/src/main.rs
+++ b/src/uu/chmod/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_chmod);
+uucore::bin!(uu_chmod);
diff --git a/src/uu/chown/Cargo.toml b/src/uu/chown/Cargo.toml
index 20381c660..7db67752c 100644
--- a/src/uu/chown/Cargo.toml
+++ b/src/uu/chown/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_chown"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chown ~ (uutils) change the ownership of FILE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/chown"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chown"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/chown.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
 
 [[bin]]
 name = "chown"
diff --git a/src/uu/chown/LICENSE b/src/uu/chown/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/chown/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/chown/src/chown.rs b/src/uu/chown/src/chown.rs
index f24c4ec89..3add9df1f 100644
--- a/src/uu/chown/src/chown.rs
+++ b/src/uu/chown/src/chown.rs
@@ -9,23 +9,21 @@
 
 use uucore::display::Quotable;
 pub use uucore::entries::{self, Group, Locate, Passwd};
+use uucore::format_usage;
 use uucore::perms::{chown_base, options, IfFrom};
 
 use uucore::error::{FromIo, UResult, USimpleError};
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 
 use std::fs;
 use std::os::unix::fs::MetadataExt;
 
 static ABOUT: &str = "change file owner and group";
 
-fn get_usage() -> String {
-    format!(
-        "{0} [OPTION]... [OWNER][:[GROUP]] FILE...\n{0} [OPTION]... --reference=RFILE FILE...",
-        uucore::execution_phrase()
-    )
-}
+const USAGE: &str = "\
+    {} [OPTION]... [OWNER][:[GROUP]] FILE...
+    {} [OPTION]... --reference=RFILE FILE...";
 
 fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)> {
     let filter = if let Some(spec) = matches.value_of(options::FROM) {
@@ -54,12 +52,10 @@ fn parse_gid_uid_and_filter(matches: &ArgMatches) -> UResult<(Option<u32>, Optio
     Ok((dest_gid, dest_uid, filter))
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = get_usage();
-
     chown_base(
-        uu_app().usage(&usage[..]),
+        uu_app(),
         args,
         options::ARG_OWNER,
         parse_gid_uid_and_filter,
@@ -67,18 +63,25 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     )
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::verbosity::CHANGES)
-                .short("c")
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information."),
+        )
+        .arg(
+            Arg::new(options::verbosity::CHANGES)
+                .short('c')
                 .long(options::verbosity::CHANGES)
                 .help("like verbose but report only when a change is made"),
         )
         .arg(
-            Arg::with_name(options::dereference::DEREFERENCE)
+            Arg::new(options::dereference::DEREFERENCE)
                 .long(options::dereference::DEREFERENCE)
                 .help(
                     "affect the referent of each symbolic link (this is the default), \
@@ -86,8 +89,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::dereference::NO_DEREFERENCE)
-                .short("h")
+            Arg::new(options::dereference::NO_DEREFERENCE)
+                .short('h')
                 .long(options::dereference::NO_DEREFERENCE)
                 .help(
                     "affect symbolic links instead of any referenced file \
@@ -95,7 +98,7 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::FROM)
+            Arg::new(options::FROM)
                 .long(options::FROM)
                 .help(
                     "change the owner and/or group of each file only if its \
@@ -106,60 +109,60 @@ pub fn uu_app() -> App<'static, 'static> {
                 .value_name("CURRENT_OWNER:CURRENT_GROUP"),
         )
         .arg(
-            Arg::with_name(options::preserve_root::PRESERVE)
+            Arg::new(options::preserve_root::PRESERVE)
                 .long(options::preserve_root::PRESERVE)
                 .help("fail to operate recursively on '/'"),
         )
         .arg(
-            Arg::with_name(options::preserve_root::NO_PRESERVE)
+            Arg::new(options::preserve_root::NO_PRESERVE)
                 .long(options::preserve_root::NO_PRESERVE)
                 .help("do not treat '/' specially (the default)"),
         )
         .arg(
-            Arg::with_name(options::verbosity::QUIET)
+            Arg::new(options::verbosity::QUIET)
                 .long(options::verbosity::QUIET)
                 .help("suppress most error messages"),
         )
         .arg(
-            Arg::with_name(options::RECURSIVE)
-                .short("R")
+            Arg::new(options::RECURSIVE)
+                .short('R')
                 .long(options::RECURSIVE)
                 .help("operate on files and directories recursively"),
         )
         .arg(
-            Arg::with_name(options::REFERENCE)
+            Arg::new(options::REFERENCE)
                 .long(options::REFERENCE)
                 .help("use RFILE's owner and group rather than specifying OWNER:GROUP values")
                 .value_name("RFILE")
                 .min_values(1),
         )
         .arg(
-            Arg::with_name(options::verbosity::SILENT)
-                .short("f")
+            Arg::new(options::verbosity::SILENT)
+                .short('f')
                 .long(options::verbosity::SILENT),
         )
         .arg(
-            Arg::with_name(options::traverse::TRAVERSE)
-                .short(options::traverse::TRAVERSE)
+            Arg::new(options::traverse::TRAVERSE)
+                .short(options::traverse::TRAVERSE.chars().next().unwrap())
                 .help("if a command line argument is a symbolic link to a directory, traverse it")
                 .overrides_with_all(&[options::traverse::EVERY, options::traverse::NO_TRAVERSE]),
         )
         .arg(
-            Arg::with_name(options::traverse::EVERY)
-                .short(options::traverse::EVERY)
+            Arg::new(options::traverse::EVERY)
+                .short(options::traverse::EVERY.chars().next().unwrap())
                 .help("traverse every symbolic link to a directory encountered")
                 .overrides_with_all(&[options::traverse::TRAVERSE, options::traverse::NO_TRAVERSE]),
         )
         .arg(
-            Arg::with_name(options::traverse::NO_TRAVERSE)
-                .short(options::traverse::NO_TRAVERSE)
+            Arg::new(options::traverse::NO_TRAVERSE)
+                .short(options::traverse::NO_TRAVERSE.chars().next().unwrap())
                 .help("do not traverse any symbolic links (default)")
                 .overrides_with_all(&[options::traverse::TRAVERSE, options::traverse::EVERY]),
         )
         .arg(
-            Arg::with_name(options::verbosity::VERBOSE)
+            Arg::new(options::verbosity::VERBOSE)
                 .long(options::verbosity::VERBOSE)
-                .short("v")
+                .short('v')
                 .help("output a diagnostic for every file processed"),
         )
 }
@@ -183,7 +186,7 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
 
     let uid = if !user.is_empty() {
         Some(match Passwd::locate(user) {
-            Ok(u) => u.uid(), // We have been able to get the uid
+            Ok(u) => u.uid, // We have been able to get the uid
             Err(_) =>
             // we have NOT been able to find the uid
             // but we could be in the case where we have user.group
@@ -208,7 +211,7 @@ fn parse_spec(spec: &str, sep: char) -> UResult<(Option<u32>, Option<u32>)> {
         Some(
             Group::locate(group)
                 .map_err(|_| USimpleError::new(1, format!("invalid group: {}", spec.quote())))?
-                .gid(),
+                .gid,
         )
     } else {
         None
diff --git a/src/uu/chown/src/main.rs b/src/uu/chown/src/main.rs
index b3ed39970..db3a4f1d2 100644
--- a/src/uu/chown/src/main.rs
+++ b/src/uu/chown/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_chown);
+uucore::bin!(uu_chown);
diff --git a/src/uu/chroot/Cargo.toml b/src/uu/chroot/Cargo.toml
index 362e43b59..8976f8256 100644
--- a/src/uu/chroot/Cargo.toml
+++ b/src/uu/chroot/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_chroot"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "chroot ~ (uutils) run COMMAND under a new root directory"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/chroot"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chroot"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/chroot.rs"
 
 [dependencies]
-clap= "2.33"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries"] }
 
 [[bin]]
 name = "chroot"
diff --git a/src/uu/chroot/LICENSE b/src/uu/chroot/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/chroot/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/chroot/src/chroot.rs b/src/uu/chroot/src/chroot.rs
index 55097c1bb..713336104 100644
--- a/src/uu/chroot/src/chroot.rs
+++ b/src/uu/chroot/src/chroot.rs
@@ -7,20 +7,20 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) NEWROOT Userspec pstatus
+mod error;
 
-#[macro_use]
-extern crate uucore;
-use clap::{crate_version, App, Arg};
+use crate::error::ChrootError;
+use clap::{crate_version, Arg, Command};
 use std::ffi::CString;
 use std::io::Error;
 use std::path::Path;
-use std::process::Command;
-use uucore::display::Quotable;
+use std::process;
+use uucore::error::{set_exit_code, UResult};
 use uucore::libc::{self, chroot, setgid, setgroups, setuid};
-use uucore::{entries, InvalidEncodingHandling};
+use uucore::{entries, format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "Run COMMAND with root directory set to NEWROOT.";
-static SYNTAX: &str = "[OPTION]... NEWROOT [COMMAND [ARG]...]";
+static USAGE: &str = "{} [OPTION]... NEWROOT [COMMAND [ARG]...]";
 
 mod options {
     pub const NEWROOT: &str = "newroot";
@@ -31,7 +31,8 @@ mod options {
     pub const COMMAND: &str = "command";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -44,19 +45,11 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     let newroot: &Path = match matches.value_of(options::NEWROOT) {
         Some(v) => Path::new(v),
-        None => crash!(
-            1,
-            "Missing operand: NEWROOT\nTry '{} --help' for more information.",
-            uucore::execution_phrase()
-        ),
+        None => return Err(ChrootError::MissingNewRoot.into()),
     };
 
     if !newroot.is_dir() {
-        crash!(
-            1,
-            "cannot change root directory to {}: no such directory",
-            newroot.quote()
-        );
+        return Err(ChrootError::NoSuchDirectory(format!("{}", newroot.display())).into());
     }
 
     let commands = match matches.values_of(options::COMMAND) {
@@ -82,65 +75,60 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     let chroot_args = &command[1..];
 
     // NOTE: Tests can only trigger code beyond this point if they're invoked with root permissions
-    set_context(newroot, &matches);
+    set_context(newroot, &matches)?;
 
-    let pstatus = Command::new(chroot_command)
+    let pstatus = match process::Command::new(chroot_command)
         .args(chroot_args)
         .status()
-        .unwrap_or_else(|e| {
-            // TODO: Exit status:
-            // 125 if chroot itself fails
-            // 126 if command is found but cannot be invoked
-            // 127 if command cannot be found
-            crash!(
-                1,
-                "failed to run command {}: {}",
-                command[0].to_string().quote(),
-                e
-            )
-        });
+    {
+        Ok(status) => status,
+        Err(e) => return Err(ChrootError::CommandFailed(command[0].to_string(), e).into()),
+    };
 
-    if pstatus.success() {
+    let code = if pstatus.success() {
         0
     } else {
         pstatus.code().unwrap_or(-1)
-    }
+    };
+    set_exit_code(code);
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .usage(SYNTAX)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::NEWROOT)
-                .hidden(true)
+            Arg::new(options::NEWROOT)
+                .hide(true)
                 .required(true)
                 .index(1),
         )
         .arg(
-            Arg::with_name(options::USER)
-                .short("u")
+            Arg::new(options::USER)
+                .short('u')
                 .long(options::USER)
                 .help("User (ID or name) to switch before running the program")
                 .value_name("USER"),
         )
         .arg(
-            Arg::with_name(options::GROUP)
-                .short("g")
+            Arg::new(options::GROUP)
+                .short('g')
                 .long(options::GROUP)
                 .help("Group (ID or name) to switch to")
                 .value_name("GROUP"),
         )
         .arg(
-            Arg::with_name(options::GROUPS)
-                .short("G")
+            Arg::new(options::GROUPS)
+                .short('G')
                 .long(options::GROUPS)
                 .help("Comma-separated list of groups to switch to")
                 .value_name("GROUP1,GROUP2..."),
         )
         .arg(
-            Arg::with_name(options::USERSPEC)
+            Arg::new(options::USERSPEC)
                 .long(options::USERSPEC)
                 .help(
                     "Colon-separated user and group to switch to. \
@@ -150,14 +138,14 @@ pub fn uu_app() -> App<'static, 'static> {
                 .value_name("USER:GROUP"),
         )
         .arg(
-            Arg::with_name(options::COMMAND)
-                .hidden(true)
-                .multiple(true)
+            Arg::new(options::COMMAND)
+                .hide(true)
+                .multiple_occurrences(true)
                 .index(2),
         )
 }
 
-fn set_context(root: &Path, options: &clap::ArgMatches) {
+fn set_context(root: &Path, options: &clap::ArgMatches) -> UResult<()> {
     let userspec_str = options.value_of(options::USERSPEC);
     let user_str = options.value_of(options::USER).unwrap_or_default();
     let group_str = options.value_of(options::GROUP).unwrap_or_default();
@@ -166,7 +154,7 @@ fn set_context(root: &Path, options: &clap::ArgMatches) {
         Some(u) => {
             let s: Vec<&str> = u.split(':').collect();
             if s.len() != 2 || s.iter().any(|&spec| spec.is_empty()) {
-                crash!(1, "invalid userspec: {}", u.quote())
+                return Err(ChrootError::InvalidUserspec(u.to_string()).into());
             };
             s
         }
@@ -179,83 +167,79 @@ fn set_context(root: &Path, options: &clap::ArgMatches) {
         (userspec[0], userspec[1])
     };
 
-    enter_chroot(root);
+    enter_chroot(root)?;
 
-    set_groups_from_str(groups_str);
-    set_main_group(group);
-    set_user(user);
+    set_groups_from_str(groups_str)?;
+    set_main_group(group)?;
+    set_user(user)?;
+    Ok(())
 }
 
-fn enter_chroot(root: &Path) {
+fn enter_chroot(root: &Path) -> UResult<()> {
     std::env::set_current_dir(root).unwrap();
     let err = unsafe {
         chroot(CString::new(".").unwrap().as_bytes_with_nul().as_ptr() as *const libc::c_char)
     };
-    if err != 0 {
-        crash!(
-            1,
-            "cannot chroot to {}: {}",
-            root.quote(),
-            Error::last_os_error()
-        )
-    };
-}
-
-fn set_main_group(group: &str) {
-    if !group.is_empty() {
-        let group_id = match entries::grp2gid(group) {
-            Ok(g) => g,
-            _ => crash!(1, "no such group: {}", group.maybe_quote()),
-        };
-        let err = unsafe { setgid(group_id) };
-        if err != 0 {
-            crash!(
-                1,
-                "cannot set gid to {}: {}",
-                group_id,
-                Error::last_os_error()
-            )
-        }
+    if err == 0 {
+        Ok(())
+    } else {
+        Err(ChrootError::CannotEnter(format!("{}", root.display()), Error::last_os_error()).into())
     }
 }
 
+fn set_main_group(group: &str) -> UResult<()> {
+    if !group.is_empty() {
+        let group_id = match entries::grp2gid(group) {
+            Ok(g) => g,
+            _ => return Err(ChrootError::NoSuchGroup(group.to_string()).into()),
+        };
+        let err = unsafe { setgid(group_id) };
+        if err != 0 {
+            return Err(
+                ChrootError::SetGidFailed(group_id.to_string(), Error::last_os_error()).into(),
+            );
+        }
+    }
+    Ok(())
+}
+
 #[cfg(any(target_vendor = "apple", target_os = "freebsd"))]
-fn set_groups(groups: Vec<libc::gid_t>) -> libc::c_int {
+fn set_groups(groups: &[libc::gid_t]) -> libc::c_int {
     unsafe { setgroups(groups.len() as libc::c_int, groups.as_ptr()) }
 }
 
 #[cfg(target_os = "linux")]
-fn set_groups(groups: Vec<libc::gid_t>) -> libc::c_int {
+fn set_groups(groups: &[libc::gid_t]) -> libc::c_int {
     unsafe { setgroups(groups.len() as libc::size_t, groups.as_ptr()) }
 }
 
-fn set_groups_from_str(groups: &str) {
+fn set_groups_from_str(groups: &str) -> UResult<()> {
     if !groups.is_empty() {
-        let groups_vec: Vec<libc::gid_t> = groups
-            .split(',')
-            .map(|x| match entries::grp2gid(x) {
+        let mut groups_vec = vec![];
+        for group in groups.split(',') {
+            let gid = match entries::grp2gid(group) {
                 Ok(g) => g,
-                _ => crash!(1, "no such group: {}", x),
-            })
-            .collect();
-        let err = set_groups(groups_vec);
+                Err(_) => return Err(ChrootError::NoSuchGroup(group.to_string()).into()),
+            };
+            groups_vec.push(gid);
+        }
+        let err = set_groups(&groups_vec);
         if err != 0 {
-            crash!(1, "cannot set groups: {}", Error::last_os_error())
+            return Err(ChrootError::SetGroupsFailed(Error::last_os_error()).into());
         }
     }
+    Ok(())
 }
 
-fn set_user(user: &str) {
+fn set_user(user: &str) -> UResult<()> {
     if !user.is_empty() {
         let user_id = entries::usr2uid(user).unwrap();
         let err = unsafe { setuid(user_id as libc::uid_t) };
         if err != 0 {
-            crash!(
-                1,
-                "cannot set user to {}: {}",
-                user.maybe_quote(),
-                Error::last_os_error()
-            )
+            return Err(
+                ChrootError::SetUserFailed(user.to_string(), Error::last_os_error()).into(),
+            );
         }
     }
+    Ok(())
 }
diff --git a/src/uu/chroot/src/error.rs b/src/uu/chroot/src/error.rs
new file mode 100644
index 000000000..69e8ac54b
--- /dev/null
+++ b/src/uu/chroot/src/error.rs
@@ -0,0 +1,81 @@
+//  * 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 NEWROOT Userspec userspec
+//! Errors returned by chroot.
+use std::fmt::Display;
+use std::io::Error;
+use uucore::display::Quotable;
+use uucore::error::UError;
+
+/// Errors that can happen while executing chroot.
+#[derive(Debug)]
+pub enum ChrootError {
+    /// Failed to enter the specified directory.
+    CannotEnter(String, Error),
+
+    /// Failed to execute the specified command.
+    CommandFailed(String, Error),
+
+    /// The given user and group specification was invalid.
+    InvalidUserspec(String),
+
+    /// The new root directory was not given.
+    MissingNewRoot,
+
+    /// Failed to find the specified group.
+    NoSuchGroup(String),
+
+    /// The given directory does not exist.
+    NoSuchDirectory(String),
+
+    /// The call to `setgid()` failed.
+    SetGidFailed(String, Error),
+
+    /// The call to `setgroups()` failed.
+    SetGroupsFailed(Error),
+
+    /// The call to `setuid()` failed.
+    SetUserFailed(String, Error),
+}
+
+impl std::error::Error for ChrootError {}
+
+impl UError for ChrootError {
+    // TODO: Exit status:
+    // 125 if chroot itself fails
+    // 126 if command is found but cannot be invoked
+    // 127 if command cannot be found
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+impl Display for ChrootError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::CannotEnter(s, e) => write!(f, "cannot chroot to {}: {}", s.quote(), e,),
+            Self::CommandFailed(s, e) => {
+                write!(f, "failed to run command {}: {}", s.to_string().quote(), e,)
+            }
+            Self::InvalidUserspec(s) => write!(f, "invalid userspec: {}", s.quote(),),
+            Self::MissingNewRoot => write!(
+                f,
+                "Missing operand: NEWROOT\nTry '{} --help' for more information.",
+                uucore::execution_phrase(),
+            ),
+            Self::NoSuchGroup(s) => write!(f, "no such group: {}", s.maybe_quote(),),
+            Self::NoSuchDirectory(s) => write!(
+                f,
+                "cannot change root directory to {}: no such directory",
+                s.quote(),
+            ),
+            Self::SetGidFailed(s, e) => write!(f, "cannot set gid to {}: {}", s, e),
+            Self::SetGroupsFailed(e) => write!(f, "cannot set groups: {}", e),
+            Self::SetUserFailed(s, e) => {
+                write!(f, "cannot set user to {}: {}", s.maybe_quote(), e)
+            }
+        }
+    }
+}
diff --git a/src/uu/chroot/src/main.rs b/src/uu/chroot/src/main.rs
index 0ca88cfaf..a8ccd8254 100644
--- a/src/uu/chroot/src/main.rs
+++ b/src/uu/chroot/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_chroot);
+uucore::bin!(uu_chroot);
diff --git a/src/uu/cksum/Cargo.toml b/src/uu/cksum/Cargo.toml
index b7f81d74b..50fdccf88 100644
--- a/src/uu/cksum/Cargo.toml
+++ b/src/uu/cksum/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_cksum"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cksum ~ (uutils) display CRC and size of input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/cksum"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cksum"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,9 @@ edition = "2018"
 path = "src/cksum.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "cksum"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/cksum/LICENSE b/src/uu/cksum/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/cksum/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/cksum/src/cksum.rs b/src/uu/cksum/src/cksum.rs
index 92853a3e8..e901e0820 100644
--- a/src/uu/cksum/src/cksum.rs
+++ b/src/uu/cksum/src/cksum.rs
@@ -6,23 +6,21 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) fname
-
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::File;
 use std::io::{self, stdin, BufReader, Read};
 use std::path::Path;
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
 use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, show};
 
 // NOTE: CRC_TABLE_LEN *must* be <= 256 as we cast 0..CRC_TABLE_LEN to u8
 const CRC_TABLE_LEN: usize = 256;
 const CRC_TABLE: [u32; CRC_TABLE_LEN] = generate_crc_table();
 
 const NAME: &str = "cksum";
-const SYNTAX: &str = "[OPTIONS] [FILE]...";
+const USAGE: &str = "{} [OPTIONS] [FILE]...";
 const SUMMARY: &str = "Print CRC and size for each file";
 
 const fn generate_crc_table() -> [u32; CRC_TABLE_LEN] {
@@ -82,27 +80,18 @@ fn cksum(fname: &str) -> io::Result<(u32, usize)> {
     let mut crc = 0u32;
     let mut size = 0usize;
 
-    let file;
     let mut rd: Box<dyn Read> = match fname {
         "-" => Box::new(stdin()),
         _ => {
-            let path = &Path::new(fname);
-            if path.is_dir() {
-                return Err(std::io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    "Is a directory",
-                ));
-            };
-            // Silent the warning as we want to the error message
-            #[allow(clippy::question_mark)]
-            if path.metadata().is_err() {
-                return Err(std::io::Error::new(
-                    io::ErrorKind::NotFound,
-                    "No such file or directory",
-                ));
-            };
-            file = File::open(&path)?;
-            Box::new(BufReader::new(file))
+            let p = Path::new(fname);
+
+            // Directories should not give an error, but should be interpreted
+            // as empty files to match GNU semantics.
+            if p.is_dir() {
+                Box::new(BufReader::new(io::empty())) as Box<dyn Read>
+            } else {
+                Box::new(BufReader::new(File::open(p)?)) as Box<dyn Read>
+            }
         }
     };
 
@@ -123,7 +112,8 @@ mod options {
     pub static FILE: &str = "file";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
@@ -136,35 +126,30 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     };
 
     if files.is_empty() {
-        match cksum("-") {
-            Ok((crc, size)) => println!("{} {}", crc, size),
-            Err(err) => {
-                show_error!("-: {}", err);
-                return 2;
-            }
-        }
-        return 0;
+        let (crc, size) = cksum("-")?;
+        println!("{} {}", crc, size);
+        return Ok(());
     }
 
-    let mut exit_code = 0;
     for fname in &files {
-        match cksum(fname.as_ref()) {
+        match cksum(fname.as_ref()).map_err_context(|| format!("{}", fname.maybe_quote())) {
             Ok((crc, size)) => println!("{} {} {}", crc, size, fname),
-            Err(err) => {
-                show_error!("{}: {}", fname.maybe_quote(), err);
-                exit_code = 2;
-            }
-        }
+            Err(err) => show!(err),
+        };
     }
-
-    exit_code
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
         .about(SUMMARY)
-        .usage(SYNTAX)
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .arg(
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
 }
diff --git a/src/uu/cksum/src/main.rs b/src/uu/cksum/src/main.rs
index b8a8f6b33..8cab56681 100644
--- a/src/uu/cksum/src/main.rs
+++ b/src/uu/cksum/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_cksum);
+uucore::bin!(uu_cksum);
diff --git a/src/uu/comm/Cargo.toml b/src/uu/comm/Cargo.toml
index abcbff57b..a6de62a58 100644
--- a/src/uu/comm/Cargo.toml
+++ b/src/uu/comm/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_comm"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "comm ~ (uutils) compare sorted inputs"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/comm"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/comm"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,9 @@ edition = "2018"
 path = "src/comm.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "comm"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/comm/LICENSE b/src/uu/comm/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/comm/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/comm/src/comm.rs b/src/uu/comm/src/comm.rs
index 56af42fd9..2207493d3 100644
--- a/src/uu/comm/src/comm.rs
+++ b/src/uu/comm/src/comm.rs
@@ -11,12 +11,15 @@ use std::cmp::Ordering;
 use std::fs::File;
 use std::io::{self, stdin, BufRead, BufReader, Stdin};
 use std::path::Path;
-use uucore::InvalidEncodingHandling;
+use uucore::error::FromIo;
+use uucore::error::UResult;
+use uucore::{format_usage, InvalidEncodingHandling};
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 
 static ABOUT: &str = "compare two sorted files line by line";
 static LONG_HELP: &str = "";
+const USAGE: &str = "{} [OPTION]... FILE1 FILE2";
 
 mod options {
     pub const COLUMN_1: &str = "1";
@@ -28,10 +31,6 @@ mod options {
     pub const FILE_2: &str = "FILE2";
 }
 
-fn usage() -> String {
-    format!("{} [OPTION]... FILE1 FILE2", uucore::execution_phrase())
-}
-
 fn mkdelim(col: usize, opts: &ArgMatches) -> String {
     let mut s = String::new();
     let delim = opts.value_of(options::DELIMITER).unwrap();
@@ -128,50 +127,52 @@ fn open_file(name: &str) -> io::Result<LineReader> {
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
-
-    let mut f1 = open_file(matches.value_of(options::FILE_1).unwrap()).unwrap();
-    let mut f2 = open_file(matches.value_of(options::FILE_2).unwrap()).unwrap();
+    let matches = uu_app().get_matches_from(args);
+    let filename1 = matches.value_of(options::FILE_1).unwrap();
+    let filename2 = matches.value_of(options::FILE_2).unwrap();
+    let mut f1 = open_file(filename1).map_err_context(|| filename1.to_string())?;
+    let mut f2 = open_file(filename2).map_err_context(|| filename2.to_string())?;
 
     comm(&mut f1, &mut f2, &matches);
-
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::COLUMN_1)
-                .short(options::COLUMN_1)
+            Arg::new(options::COLUMN_1)
+                .short('1')
                 .help("suppress column 1 (lines unique to FILE1)"),
         )
         .arg(
-            Arg::with_name(options::COLUMN_2)
-                .short(options::COLUMN_2)
+            Arg::new(options::COLUMN_2)
+                .short('2')
                 .help("suppress column 2 (lines unique to FILE2)"),
         )
         .arg(
-            Arg::with_name(options::COLUMN_3)
-                .short(options::COLUMN_3)
+            Arg::new(options::COLUMN_3)
+                .short('3')
                 .help("suppress column 3 (lines that appear in both files)"),
         )
         .arg(
-            Arg::with_name(options::DELIMITER)
+            Arg::new(options::DELIMITER)
                 .long(options::DELIMITER)
                 .help("separate columns with STR")
                 .value_name("STR")
                 .default_value(options::DELIMITER_DEFAULT)
                 .hide_default_value(true),
         )
-        .arg(Arg::with_name(options::FILE_1).required(true))
-        .arg(Arg::with_name(options::FILE_2).required(true))
+        .arg(Arg::new(options::FILE_1).required(true))
+        .arg(Arg::new(options::FILE_2).required(true))
 }
diff --git a/src/uu/comm/src/main.rs b/src/uu/comm/src/main.rs
index 07ac07544..0417389c2 100644
--- a/src/uu/comm/src/main.rs
+++ b/src/uu/comm/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_comm);
+uucore::bin!(uu_comm);
diff --git a/src/uu/cp/Cargo.toml b/src/uu/cp/Cargo.toml
index 891bf0244..452e1e8cf 100644
--- a/src/uu/cp/Cargo.toml
+++ b/src/uu/cp/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_cp"
-version = "0.0.8"
+version = "0.0.13"
 authors = [
     "Jordy Dickinson <jordy.dickinson@gmail.com>",
     "Joshua S. Miller <jsmiller@uchicago.edu>",
@@ -10,7 +10,7 @@ license = "MIT"
 description = "cp ~ (uutils) copy SOURCE to DESTINATION"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/cp"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cp"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -19,24 +19,23 @@ edition = "2018"
 path = "src/cp.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 filetime = "0.2"
-libc = "0.2.85"
-quick-error = "1.2.3"
-selinux = { version="0.2.3", optional=true }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries", "fs", "perms", "mode"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+libc = "0.2.121"
+quick-error = "2.0.1"
+selinux = { version="0.2", optional=true }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries", "fs", "perms", "mode"] }
 walkdir = "2.2"
 
 [target.'cfg(target_os = "linux")'.dependencies]
-ioctl-sys = "0.6"
+ioctl-sys = "0.8"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version="0.3", features=["fileapi"] }
 
 [target.'cfg(unix)'.dependencies]
 xattr="0.2.1"
-exacl= { version = "0.6.0", optional=true }
+exacl= { version = "0.8.0", optional=true }
 
 [[bin]]
 name = "cp"
@@ -45,7 +44,3 @@ path = "src/main.rs"
 [features]
 feat_selinux = ["selinux"]
 feat_acl = ["exacl"]
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/cp/LICENSE b/src/uu/cp/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/cp/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/cp/src/cp.rs b/src/uu/cp/src/cp.rs
index 518a2262c..d69bb705b 100644
--- a/src/uu/cp/src/cp.rs
+++ b/src/uu/cp/src/cp.rs
@@ -8,7 +8,7 @@
 // For the full copyright and license information, please view the LICENSE file
 // that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) ficlone linkgs lstat nlink nlinks pathbuf reflink strs xattrs
+// spell-checker:ignore (ToDO) ficlone linkgs lstat nlink nlinks pathbuf reflink strs xattrs symlinked
 
 #[cfg(target_os = "linux")]
 #[macro_use]
@@ -19,6 +19,8 @@ extern crate quick_error;
 extern crate uucore;
 
 use uucore::display::Quotable;
+use uucore::format_usage;
+use uucore::fs::FileInformation;
 #[cfg(windows)]
 use winapi::um::fileapi::CreateFileW;
 #[cfg(windows)]
@@ -26,8 +28,10 @@ use winapi::um::fileapi::GetFileInformationByHandle;
 
 use std::borrow::Cow;
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use filetime::FileTime;
+#[cfg(unix)]
+use libc::mkfifo;
 use quick_error::ResultExt;
 use std::collections::HashSet;
 use std::env;
@@ -41,6 +45,10 @@ use std::fs::OpenOptions;
 use std::io;
 use std::io::{stdin, stdout, Write};
 use std::mem;
+#[cfg(unix)]
+use std::os::unix::ffi::OsStrExt;
+#[cfg(unix)]
+use std::os::unix::fs::{FileTypeExt, PermissionsExt};
 #[cfg(target_os = "linux")]
 use std::os::unix::io::AsRawFd;
 #[cfg(windows)]
@@ -53,9 +61,6 @@ use uucore::error::{set_exit_code, ExitCode, UError, UResult};
 use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
 use walkdir::WalkDir;
 
-#[cfg(unix)]
-use std::os::unix::fs::PermissionsExt;
-
 #[cfg(target_os = "linux")]
 ioctl!(write ficlone with 0x94, 9; std::os::raw::c_int);
 
@@ -63,14 +68,14 @@ quick_error! {
     #[derive(Debug)]
     pub enum Error {
         /// Simple io::Error wrapper
-        IoErr(err: io::Error) { from() cause(err) display("{}", err) }
+        IoErr(err: io::Error) { from() source(err) display("{}", err)}
 
         /// Wrapper for io::Error with path context
         IoErrContext(err: io::Error, path: String) {
             display("{}: {}", path, err)
             context(path: &'a str, err: io::Error) -> (err, path.to_owned())
             context(context: String, err: io::Error) -> (err, context)
-            cause(err)
+            source(err)
         }
 
         /// General copy error
@@ -85,7 +90,7 @@ quick_error! {
         NotAllFilesCopied {}
 
         /// Simple walkdir::Error wrapper
-        WalkDirErr(err: walkdir::Error) { from() display("{}", err) cause(err) }
+        WalkDirErr(err: walkdir::Error) { from() display("{}", err) source(err) }
 
         /// Simple std::path::StripPrefixError wrapper
         StripPrefixError(err: StripPrefixError) { from() }
@@ -148,7 +153,7 @@ pub type Target = PathBuf;
 pub type TargetSlice = Path;
 
 /// Specifies whether when overwrite files
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Clone, Copy, Eq, PartialEq)]
 pub enum ClobberMode {
     Force,
     RemoveDestination,
@@ -156,7 +161,7 @@ pub enum ClobberMode {
 }
 
 /// Specifies whether when overwrite files
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Clone, Copy, Eq, PartialEq)]
 pub enum OverwriteMode {
     /// [Default] Always overwrite existing files
     Clobber(ClobberMode),
@@ -229,14 +234,10 @@ static ABOUT: &str = "Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.";
 static LONG_HELP: &str = "";
 static EXIT_ERR: i32 = 1;
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [-T] SOURCE DEST
-    {0} [OPTION]... SOURCE... DIRECTORY
-    {0} [OPTION]... -t DIRECTORY SOURCE...",
-        uucore::execution_phrase()
-    )
-}
+const USAGE: &str = "\
+    {} [OPTION]... [-T] SOURCE DEST
+    {} [OPTION]... SOURCE... DIRECTORY
+    {} [OPTION]... -t DIRECTORY SOURCE...";
 
 // Argument constants
 mod options {
@@ -295,174 +296,186 @@ static DEFAULT_ATTRIBUTES: &[Attribute] = &[
     Attribute::Timestamps,
 ];
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    const MODE_ARGS: &[&str] = &[
+        options::LINK,
+        options::REFLINK,
+        options::SYMBOLIC_LINK,
+        options::ATTRIBUTES_ONLY,
+        options::COPY_CONTENTS,
+    ];
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .arg(Arg::with_name(options::TARGET_DIRECTORY)
-             .short("t")
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .arg(Arg::new(options::TARGET_DIRECTORY)
+             .short('t')
              .conflicts_with(options::NO_TARGET_DIRECTORY)
              .long(options::TARGET_DIRECTORY)
              .value_name(options::TARGET_DIRECTORY)
              .takes_value(true)
+             .validator(|s| {
+                 if Path::new(s).is_dir() {
+                     return Ok(());
+                 }
+                 Err(format!("'{}' is not a directory", s))
+             })
              .help("copy all SOURCE arguments into target-directory"))
-        .arg(Arg::with_name(options::NO_TARGET_DIRECTORY)
-             .short("T")
+        .arg(Arg::new(options::NO_TARGET_DIRECTORY)
+             .short('T')
              .long(options::NO_TARGET_DIRECTORY)
              .conflicts_with(options::TARGET_DIRECTORY)
              .help("Treat DEST as a regular file and not a directory"))
-        .arg(Arg::with_name(options::INTERACTIVE)
-             .short("i")
+        .arg(Arg::new(options::INTERACTIVE)
+             .short('i')
              .long(options::INTERACTIVE)
-             .conflicts_with(options::NO_CLOBBER)
+             .overrides_with(options::NO_CLOBBER)
              .help("ask before overwriting files"))
-        .arg(Arg::with_name(options::LINK)
-             .short("l")
+        .arg(Arg::new(options::LINK)
+             .short('l')
              .long(options::LINK)
-             .overrides_with(options::REFLINK)
+             .overrides_with_all(MODE_ARGS)
              .help("hard-link files instead of copying"))
-        .arg(Arg::with_name(options::NO_CLOBBER)
-             .short("n")
+        .arg(Arg::new(options::NO_CLOBBER)
+             .short('n')
              .long(options::NO_CLOBBER)
-             .conflicts_with(options::INTERACTIVE)
+             .overrides_with(options::INTERACTIVE)
              .help("don't overwrite a file that already exists"))
-        .arg(Arg::with_name(options::RECURSIVE)
-             .short("r")
+        .arg(Arg::new(options::RECURSIVE)
+             .short('r')
              .long(options::RECURSIVE)
              // --archive sets this option
             .help("copy directories recursively"))
-        .arg(Arg::with_name(options::RECURSIVE_ALIAS)
-             .short("R")
+        .arg(Arg::new(options::RECURSIVE_ALIAS)
+             .short('R')
              .help("same as -r"))
-        .arg(Arg::with_name(options::STRIP_TRAILING_SLASHES)
+        .arg(Arg::new(options::STRIP_TRAILING_SLASHES)
              .long(options::STRIP_TRAILING_SLASHES)
              .help("remove any trailing slashes from each SOURCE argument"))
-        .arg(Arg::with_name(options::VERBOSE)
-             .short("v")
+        .arg(Arg::new(options::VERBOSE)
+             .short('v')
              .long(options::VERBOSE)
              .help("explicitly state what is being done"))
-        .arg(Arg::with_name(options::SYMBOLIC_LINK)
-             .short("s")
+        .arg(Arg::new(options::SYMBOLIC_LINK)
+             .short('s')
              .long(options::SYMBOLIC_LINK)
-             .conflicts_with(options::LINK)
-             .overrides_with(options::REFLINK)
+             .overrides_with_all(MODE_ARGS)
              .help("make symbolic links instead of copying"))
-        .arg(Arg::with_name(options::FORCE)
-             .short("f")
+        .arg(Arg::new(options::FORCE)
+             .short('f')
              .long(options::FORCE)
              .help("if an existing destination file cannot be opened, remove it and \
                     try again (this option is ignored when the -n option is also used). \
                     Currently not implemented for Windows."))
-        .arg(Arg::with_name(options::REMOVE_DESTINATION)
+        .arg(Arg::new(options::REMOVE_DESTINATION)
              .long(options::REMOVE_DESTINATION)
-             .conflicts_with(options::FORCE)
+             .overrides_with(options::FORCE)
              .help("remove each existing destination file before attempting to open it \
-                    (contrast with --force). On Windows, current only works for writeable files."))
+                    (contrast with --force). On Windows, currently only works for writeable files."))
         .arg(backup_control::arguments::backup())
         .arg(backup_control::arguments::backup_no_args())
         .arg(backup_control::arguments::suffix())
-        .arg(Arg::with_name(options::UPDATE)
-             .short("u")
+        .arg(Arg::new(options::UPDATE)
+             .short('u')
              .long(options::UPDATE)
              .help("copy only when the SOURCE file is newer than the destination file \
                     or when the destination file is missing"))
-        .arg(Arg::with_name(options::REFLINK)
+        .arg(Arg::new(options::REFLINK)
              .long(options::REFLINK)
              .takes_value(true)
              .value_name("WHEN")
+             .overrides_with_all(MODE_ARGS)
              .help("control clone/CoW copies. See below"))
-        .arg(Arg::with_name(options::ATTRIBUTES_ONLY)
+        .arg(Arg::new(options::ATTRIBUTES_ONLY)
              .long(options::ATTRIBUTES_ONLY)
-             .conflicts_with(options::COPY_CONTENTS)
-             .overrides_with(options::REFLINK)
+             .overrides_with_all(MODE_ARGS)
              .help("Don't copy the file data, just the attributes"))
-        .arg(Arg::with_name(options::PRESERVE)
+        .arg(Arg::new(options::PRESERVE)
              .long(options::PRESERVE)
              .takes_value(true)
-             .multiple(true)
-             .use_delimiter(true)
+             .multiple_occurrences(true)
+             .use_value_delimiter(true)
              .possible_values(PRESERVABLE_ATTRIBUTES)
              .min_values(0)
              .value_name("ATTR_LIST")
-             .conflicts_with_all(&[options::PRESERVE_DEFAULT_ATTRIBUTES, options::NO_PRESERVE])
+             .overrides_with_all(&[options::ARCHIVE, options::PRESERVE_DEFAULT_ATTRIBUTES, options::NO_PRESERVE])
              // -d sets this option
              // --archive sets this option
              .help("Preserve the specified attributes (default: mode, ownership (unix only), timestamps), \
                     if possible additional attributes: context, links, xattr, all"))
-        .arg(Arg::with_name(options::PRESERVE_DEFAULT_ATTRIBUTES)
-             .short("-p")
+        .arg(Arg::new(options::PRESERVE_DEFAULT_ATTRIBUTES)
+             .short('p')
              .long(options::PRESERVE_DEFAULT_ATTRIBUTES)
-             .conflicts_with_all(&[options::PRESERVE, options::NO_PRESERVE, options::ARCHIVE])
+             .overrides_with_all(&[options::PRESERVE, options::NO_PRESERVE, options::ARCHIVE])
              .help("same as --preserve=mode,ownership(unix only),timestamps"))
-        .arg(Arg::with_name(options::NO_PRESERVE)
+        .arg(Arg::new(options::NO_PRESERVE)
              .long(options::NO_PRESERVE)
              .takes_value(true)
              .value_name("ATTR_LIST")
-             .conflicts_with_all(&[options::PRESERVE_DEFAULT_ATTRIBUTES, options::PRESERVE, options::ARCHIVE])
+             .overrides_with_all(&[options::PRESERVE_DEFAULT_ATTRIBUTES, options::PRESERVE, options::ARCHIVE])
              .help("don't preserve the specified attributes"))
-        .arg(Arg::with_name(options::PARENTS)
+        .arg(Arg::new(options::PARENTS)
             .long(options::PARENTS)
             .alias(options::PARENT)
             .help("use full source file name under DIRECTORY"))
-        .arg(Arg::with_name(options::NO_DEREFERENCE)
-             .short("-P")
+        .arg(Arg::new(options::NO_DEREFERENCE)
+             .short('P')
              .long(options::NO_DEREFERENCE)
-             .conflicts_with(options::DEREFERENCE)
+             .overrides_with(options::DEREFERENCE)
              // -d sets this option
              .help("never follow symbolic links in SOURCE"))
-        .arg(Arg::with_name(options::DEREFERENCE)
-             .short("L")
+        .arg(Arg::new(options::DEREFERENCE)
+             .short('L')
              .long(options::DEREFERENCE)
-             .conflicts_with(options::NO_DEREFERENCE)
+             .overrides_with(options::NO_DEREFERENCE)
              .help("always follow symbolic links in SOURCE"))
-        .arg(Arg::with_name(options::ARCHIVE)
-             .short("a")
+        .arg(Arg::new(options::ARCHIVE)
+             .short('a')
              .long(options::ARCHIVE)
-             .conflicts_with_all(&[options::PRESERVE_DEFAULT_ATTRIBUTES, options::PRESERVE, options::NO_PRESERVE])
+             .overrides_with_all(&[options::PRESERVE_DEFAULT_ATTRIBUTES, options::PRESERVE, options::NO_PRESERVE])
              .help("Same as -dR --preserve=all"))
-        .arg(Arg::with_name(options::NO_DEREFERENCE_PRESERVE_LINKS)
-             .short("d")
+        .arg(Arg::new(options::NO_DEREFERENCE_PRESERVE_LINKS)
+             .short('d')
              .help("same as --no-dereference --preserve=links"))
-        .arg(Arg::with_name(options::ONE_FILE_SYSTEM)
-             .short("x")
+        .arg(Arg::new(options::ONE_FILE_SYSTEM)
+             .short('x')
              .long(options::ONE_FILE_SYSTEM)
              .help("stay on this file system"))
 
         // TODO: implement the following args
-        .arg(Arg::with_name(options::COPY_CONTENTS)
+        .arg(Arg::new(options::COPY_CONTENTS)
              .long(options::COPY_CONTENTS)
-             .conflicts_with(options::ATTRIBUTES_ONLY)
+             .overrides_with(options::ATTRIBUTES_ONLY)
              .help("NotImplemented: copy contents of special files when recursive"))
-        .arg(Arg::with_name(options::SPARSE)
+        .arg(Arg::new(options::SPARSE)
              .long(options::SPARSE)
              .takes_value(true)
              .value_name("WHEN")
              .help("NotImplemented: control creation of sparse files. See below"))
-        .arg(Arg::with_name(options::CONTEXT)
+        .arg(Arg::new(options::CONTEXT)
              .long(options::CONTEXT)
              .takes_value(true)
              .value_name("CTX")
              .help("NotImplemented: set SELinux security context of destination file to default type"))
-        .arg(Arg::with_name(options::CLI_SYMBOLIC_LINKS)
-             .short("H")
+        .arg(Arg::new(options::CLI_SYMBOLIC_LINKS)
+             .short('H')
              .help("NotImplemented: follow command-line symbolic links in SOURCE"))
         // END TODO
 
-        .arg(Arg::with_name(options::PATHS)
-             .multiple(true))
+        .arg(Arg::new(options::PATHS)
+             .multiple_occurrences(true))
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
     let matches = uu_app()
         .after_help(&*format!(
             "{}\n{}",
             LONG_HELP,
             backup_control::BACKUP_CONTROL_LONG_HELP
         ))
-        .usage(&usage[..])
-        .get_matches_from(args);
+        .try_get_matches_from(args)?;
 
     let options = Options::from_matches(&matches)?;
 
@@ -493,43 +506,43 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 }
 
 impl ClobberMode {
-    fn from_matches(matches: &ArgMatches) -> ClobberMode {
+    fn from_matches(matches: &ArgMatches) -> Self {
         if matches.is_present(options::FORCE) {
-            ClobberMode::Force
+            Self::Force
         } else if matches.is_present(options::REMOVE_DESTINATION) {
-            ClobberMode::RemoveDestination
+            Self::RemoveDestination
         } else {
-            ClobberMode::Standard
+            Self::Standard
         }
     }
 }
 
 impl OverwriteMode {
-    fn from_matches(matches: &ArgMatches) -> OverwriteMode {
+    fn from_matches(matches: &ArgMatches) -> Self {
         if matches.is_present(options::INTERACTIVE) {
-            OverwriteMode::Interactive(ClobberMode::from_matches(matches))
+            Self::Interactive(ClobberMode::from_matches(matches))
         } else if matches.is_present(options::NO_CLOBBER) {
-            OverwriteMode::NoClobber
+            Self::NoClobber
         } else {
-            OverwriteMode::Clobber(ClobberMode::from_matches(matches))
+            Self::Clobber(ClobberMode::from_matches(matches))
         }
     }
 }
 
 impl CopyMode {
-    fn from_matches(matches: &ArgMatches) -> CopyMode {
+    fn from_matches(matches: &ArgMatches) -> Self {
         if matches.is_present(options::LINK) {
-            CopyMode::Link
+            Self::Link
         } else if matches.is_present(options::SYMBOLIC_LINK) {
-            CopyMode::SymLink
+            Self::SymLink
         } else if matches.is_present(options::SPARSE) {
-            CopyMode::Sparse
+            Self::Sparse
         } else if matches.is_present(options::UPDATE) {
-            CopyMode::Update
+            Self::Update
         } else if matches.is_present(options::ATTRIBUTES_ONLY) {
-            CopyMode::AttrOnly
+            Self::AttrOnly
         } else {
-            CopyMode::Copy
+            Self::Copy
         }
     }
 }
@@ -537,16 +550,16 @@ impl CopyMode {
 impl FromStr for Attribute {
     type Err = Error;
 
-    fn from_str(value: &str) -> CopyResult<Attribute> {
+    fn from_str(value: &str) -> CopyResult<Self> {
         Ok(match &*value.to_lowercase() {
-            "mode" => Attribute::Mode,
+            "mode" => Self::Mode,
             #[cfg(unix)]
-            "ownership" => Attribute::Ownership,
-            "timestamps" => Attribute::Timestamps,
+            "ownership" => Self::Ownership,
+            "timestamps" => Self::Timestamps,
             #[cfg(feature = "feat_selinux")]
-            "context" => Attribute::Context,
-            "links" => Attribute::Links,
-            "xattr" => Attribute::Xattr,
+            "context" => Self::Context,
+            "links" => Self::Links,
+            "xattr" => Self::Xattr,
             _ => {
                 return Err(Error::InvalidArgument(format!(
                     "invalid attribute {}",
@@ -575,7 +588,7 @@ fn add_all_attributes() -> Vec<Attribute> {
 }
 
 impl Options {
-    fn from_matches(matches: &ArgMatches) -> CopyResult<Options> {
+    fn from_matches(matches: &ArgMatches) -> CopyResult<Self> {
         let not_implemented_opts = vec![
             options::COPY_CONTENTS,
             options::SPARSE,
@@ -644,7 +657,7 @@ impl Options {
         // if not executed first.
         preserve_attributes.sort_unstable();
 
-        let options = Options {
+        let options = Self {
             attributes_only: matches.is_present(options::ATTRIBUTES_ONLY),
             copy_contents: matches.is_present(options::COPY_CONTENTS),
             copy_mode: CopyMode::from_matches(matches),
@@ -701,11 +714,11 @@ impl TargetType {
     ///
     /// Treat target as a dir if we have multiple sources or the target
     /// exists and already is a directory
-    fn determine(sources: &[Source], target: &TargetSlice) -> TargetType {
+    fn determine(sources: &[Source], target: &TargetSlice) -> Self {
         if sources.len() > 1 || target.is_dir() {
-            TargetType::Directory
+            Self::Directory
         } else {
-            TargetType::File
+            Self::File
         }
     }
 }
@@ -739,8 +752,8 @@ fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<S
     };
 
     if options.strip_trailing_slashes {
-        for source in paths.iter_mut() {
-            *source = source.components().as_path().to_owned()
+        for source in &mut paths {
+            *source = source.components().as_path().to_owned();
         }
     }
 
@@ -750,7 +763,7 @@ fn parse_path_args(path_args: &[String], options: &Options) -> CopyResult<(Vec<S
 fn preserve_hardlinks(
     hard_links: &mut Vec<(String, u64)>,
     source: &std::path::Path,
-    dest: std::path::PathBuf,
+    dest: &std::path::Path,
     found_hard_link: &mut bool,
 ) -> CopyResult<()> {
     // Redox does not currently support hard links
@@ -766,8 +779,8 @@ fn preserve_hardlinks(
                     let mut stat = mem::zeroed();
                     if libc::lstat(src_path.as_ptr(), &mut stat) < 0 {
                         return Err(format!(
-                            "cannot stat {:?}: {}",
-                            src_path,
+                            "cannot stat {}: {}",
+                            source.quote(),
                             std::io::Error::last_os_error()
                         )
                         .into());
@@ -803,7 +816,7 @@ fn preserve_hardlinks(
 
                 for hard_link in hard_links.iter() {
                     if hard_link.1 == inode {
-                        std::fs::hard_link(hard_link.0.clone(), dest.clone()).unwrap();
+                        std::fs::hard_link(hard_link.0.clone(), dest).unwrap();
                         *found_hard_link = true;
                     }
                 }
@@ -838,17 +851,21 @@ fn copy(sources: &[Source], target: &TargetSlice, options: &Options) -> CopyResu
 
     let mut non_fatal_errors = false;
     let mut seen_sources = HashSet::with_capacity(sources.len());
+    let mut symlinked_files = HashSet::new();
     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 {
             let mut found_hard_link = false;
             if preserve_hard_links {
                 let dest = construct_dest_path(source, target, &target_type, options)?;
-                preserve_hardlinks(&mut hard_links, source, dest, &mut found_hard_link).unwrap();
+                preserve_hardlinks(&mut hard_links, source, &dest, &mut found_hard_link)?;
             }
             if !found_hard_link {
-                if let Err(error) = copy_source(source, target, &target_type, options) {
+                if let Err(error) =
+                    copy_source(source, target, &target_type, options, &mut symlinked_files)
+                {
                     match error {
                         // When using --no-clobber, we don't want to show
                         // an error message
@@ -858,7 +875,7 @@ fn copy(sources: &[Source], target: &TargetSlice, options: &Options) -> CopyResu
                         }
                         _ => {
                             show_error!("{}", error);
-                            non_fatal_errors = true
+                            non_fatal_errors = true;
                         }
                     }
                 }
@@ -909,15 +926,16 @@ fn copy_source(
     target: &TargetSlice,
     target_type: &TargetType,
     options: &Options,
+    symlinked_files: &mut HashSet<FileInformation>,
 ) -> CopyResult<()> {
     let source_path = Path::new(&source);
     if source_path.is_dir() {
         // Copy as directory
-        copy_directory(source, target, options)
+        copy_directory(source, target, options, symlinked_files)
     } else {
         // Copy as file
         let dest = construct_dest_path(source_path, target, target_type, options)?;
-        copy_file(source_path, dest.as_path(), options)
+        copy_file(source_path, dest.as_path(), options, symlinked_files)
     }
 }
 
@@ -947,14 +965,29 @@ fn adjust_canonicalization(p: &Path) -> Cow<Path> {
 ///
 /// Any errors encountered copying files in the tree will be logged but
 /// will not cause a short-circuit.
-fn copy_directory(root: &Path, target: &TargetSlice, options: &Options) -> CopyResult<()> {
+fn copy_directory(
+    root: &Path,
+    target: &TargetSlice,
+    options: &Options,
+    symlinked_files: &mut HashSet<FileInformation>,
+) -> CopyResult<()> {
     if !options.recursive {
         return Err(format!("omitting directory {}", root.quote()).into());
     }
 
     // if no-dereference is enabled and this is a symlink, copy it as a file
     if !options.dereference && fs::symlink_metadata(root).unwrap().file_type().is_symlink() {
-        return copy_file(root, target, options);
+        return copy_file(root, target, options, symlinked_files);
+    }
+
+    // check if root is a prefix of target
+    if path_has_prefix(target, root)? {
+        return Err(format!(
+            "cannot copy a directory, {}, into itself, {}",
+            root.quote(),
+            target.quote()
+        )
+        .into());
     }
 
     let current_dir =
@@ -1011,17 +1044,25 @@ fn copy_directory(root: &Path, target: &TargetSlice, options: &Options) -> CopyR
 
         let local_to_target = target.join(&local_to_root_parent);
         if is_symlink && !options.dereference {
-            copy_link(&path, &local_to_target)?;
+            copy_link(&path, &local_to_target, symlinked_files)?;
         } else if path.is_dir() && !local_to_target.exists() {
-            or_continue!(fs::create_dir_all(local_to_target));
+            if target.is_file() {
+                return Err("cannot overwrite non-directory with directory".into());
+            }
+            fs::create_dir_all(local_to_target)?;
         } else if !path.is_dir() {
             if preserve_hard_links {
                 let mut found_hard_link = false;
                 let source = path.to_path_buf();
                 let dest = local_to_target.as_path().to_path_buf();
-                preserve_hardlinks(&mut hard_links, &source, dest, &mut found_hard_link).unwrap();
+                preserve_hardlinks(&mut hard_links, &source, &dest, &mut found_hard_link)?;
                 if !found_hard_link {
-                    match copy_file(path.as_path(), local_to_target.as_path(), options) {
+                    match copy_file(
+                        path.as_path(),
+                        local_to_target.as_path(),
+                        options,
+                        symlinked_files,
+                    ) {
                         Ok(_) => Ok(()),
                         Err(err) => {
                             if fs::symlink_metadata(&source)?.file_type().is_symlink() {
@@ -1036,7 +1077,12 @@ fn copy_directory(root: &Path, target: &TargetSlice, options: &Options) -> CopyR
                     }?;
                 }
             } else {
-                copy_file(path.as_path(), local_to_target.as_path(), options)?;
+                copy_file(
+                    path.as_path(),
+                    local_to_target.as_path(),
+                    options,
+                    symlinked_files,
+                )?;
             }
         }
     }
@@ -1047,8 +1093,8 @@ fn copy_directory(root: &Path, target: &TargetSlice, options: &Options) -> CopyR
 impl OverwriteMode {
     fn verify(&self, path: &Path) -> CopyResult<()> {
         match *self {
-            OverwriteMode::NoClobber => Err(Error::NotAllFilesCopied),
-            OverwriteMode::Interactive(_) => {
+            Self::NoClobber => Err(Error::NotAllFilesCopied),
+            Self::Interactive(_) => {
                 if prompt_yes!("{}: overwrite {}? ", uucore::util_name(), path.quote()) {
                     Ok(())
                 } else {
@@ -1058,7 +1104,7 @@ impl OverwriteMode {
                     )))
                 }
             }
-            OverwriteMode::Clobber(_) => Ok(()),
+            Self::Clobber(_) => Ok(()),
         }
     }
 }
@@ -1145,18 +1191,24 @@ fn copy_attribute(source: &Path, dest: &Path, attribute: &Attribute) -> CopyResu
     Ok(())
 }
 
-#[cfg(not(windows))]
-#[allow(clippy::unnecessary_wraps)] // needed for windows version
-fn symlink_file(source: &Path, dest: &Path, context: &str) -> CopyResult<()> {
-    match std::os::unix::fs::symlink(source, dest).context(context) {
-        Ok(_) => Ok(()),
-        Err(_) => Ok(()),
+fn symlink_file(
+    source: &Path,
+    dest: &Path,
+    context: &str,
+    symlinked_files: &mut HashSet<FileInformation>,
+) -> CopyResult<()> {
+    #[cfg(not(windows))]
+    {
+        std::os::unix::fs::symlink(source, dest).context(context)?;
     }
-}
-
-#[cfg(windows)]
-fn symlink_file(source: &Path, dest: &Path, context: &str) -> CopyResult<()> {
-    Ok(std::os::windows::fs::symlink_file(source, dest).context(context)?)
+    #[cfg(windows)]
+    {
+        std::os::windows::fs::symlink_file(source, dest).context(context)?;
+    }
+    if let Some(file_info) = FileInformation::from_path(dest, false) {
+        symlinked_files.insert(file_info);
+    }
+    Ok(())
 }
 
 fn context_for(src: &Path, dest: &Path) -> String {
@@ -1183,6 +1235,7 @@ fn handle_existing_dest(source: &Path, dest: &Path, options: &Options) -> CopyRe
     }
 
     match options.overwrite {
+        // FIXME: print that the file was removed if --verbose is enabled
         OverwriteMode::Clobber(ClobberMode::Force) => {
             if fs::metadata(dest)?.permissions().readonly() {
                 fs::remove_file(dest)?;
@@ -1198,7 +1251,8 @@ fn handle_existing_dest(source: &Path, dest: &Path, options: &Options) -> CopyRe
 }
 
 /// Copy the a file from `source` to `dest`. `source` will be dereferenced if
-/// `options.dereference` is set to true. `dest` will always be dereferenced.
+/// `options.dereference` is set to true. `dest` will be dereferenced only if
+/// the source was not a symlink.
 ///
 /// Behavior when copying to existing files is contingent on the
 /// `options.overwrite` mode. If a file is skipped, the return type
@@ -1206,11 +1260,39 @@ fn handle_existing_dest(source: &Path, dest: &Path, options: &Options) -> CopyRe
 ///
 /// The original permissions of `source` will be copied to `dest`
 /// after a successful copy.
-fn copy_file(source: &Path, dest: &Path, options: &Options) -> CopyResult<()> {
+fn copy_file(
+    source: &Path,
+    dest: &Path,
+    options: &Options,
+    symlinked_files: &mut HashSet<FileInformation>,
+) -> CopyResult<()> {
     if dest.exists() {
         handle_existing_dest(source, dest, options)?;
     }
 
+    // Fail if dest is a dangling symlink or a symlink this program created previously
+    if fs::symlink_metadata(dest)
+        .map(|m| m.file_type().is_symlink())
+        .unwrap_or(false)
+    {
+        if FileInformation::from_path(dest, false)
+            .map(|info| symlinked_files.contains(&info))
+            .unwrap_or(false)
+        {
+            return Err(Error::Error(format!(
+                "will not copy '{}' through just-created symlink '{}'",
+                source.display(),
+                dest.display()
+            )));
+        }
+        if !dest.exists() {
+            return Err(Error::Error(format!(
+                "not writing through dangling symlink '{}'",
+                dest.display()
+            )));
+        }
+    }
+
     if options.verbose {
         println!("{}", context_for(source, dest));
     }
@@ -1220,13 +1302,32 @@ fn copy_file(source: &Path, dest: &Path, options: &Options) -> CopyResult<()> {
     let context = context.as_str();
 
     // canonicalize dest and source so that later steps can work with the paths directly
-    let dest = canonicalize(dest, MissingHandling::Missing, ResolveMode::Physical).unwrap();
     let source = if options.dereference {
         canonicalize(source, MissingHandling::Missing, ResolveMode::Physical).unwrap()
     } else {
         source.to_owned()
     };
 
+    let source_file_type = fs::symlink_metadata(&source).context(context)?.file_type();
+    let source_is_symlink = source_file_type.is_symlink();
+
+    #[cfg(unix)]
+    let source_is_fifo = source_file_type.is_fifo();
+    #[cfg(not(unix))]
+    let source_is_fifo = false;
+
+    let dest_already_exists_as_symlink = fs::symlink_metadata(&dest)
+        .map(|meta| meta.file_type().is_symlink())
+        .unwrap_or(false);
+
+    let dest = if !(source_is_symlink && dest_already_exists_as_symlink) {
+        canonicalize(dest, MissingHandling::Missing, ResolveMode::Physical).unwrap()
+    } else {
+        // Don't canonicalize a symlink copied over another symlink, because
+        // then we'll end up overwriting the destination's target.
+        dest.to_path_buf()
+    };
+
     let dest_permissions = if dest.exists() {
         dest.symlink_metadata().context(context)?.permissions()
     } else {
@@ -1252,13 +1353,30 @@ fn copy_file(source: &Path, dest: &Path, options: &Options) -> CopyResult<()> {
 
     match options.copy_mode {
         CopyMode::Link => {
+            if dest.exists() {
+                let backup_path =
+                    backup_control::get_backup_path(options.backup, &dest, &options.backup_suffix);
+                if let Some(backup_path) = backup_path {
+                    backup_dest(&dest, &backup_path)?;
+                    fs::remove_file(&dest)?;
+                }
+            }
+
             fs::hard_link(&source, &dest).context(context)?;
         }
         CopyMode::Copy => {
-            copy_helper(&source, &dest, options, context)?;
+            copy_helper(
+                &source,
+                &dest,
+                options,
+                context,
+                source_is_symlink,
+                source_is_fifo,
+                symlinked_files,
+            )?;
         }
         CopyMode::SymLink => {
-            symlink_file(&source, &dest, context)?;
+            symlink_file(&source, &dest, context, symlinked_files)?;
         }
         CopyMode::Sparse => return Err(Error::NotImplemented(options::SPARSE.to_string())),
         CopyMode::Update => {
@@ -1271,10 +1389,26 @@ fn copy_file(source: &Path, dest: &Path, options: &Options) -> CopyResult<()> {
                 if src_time <= dest_time {
                     return Ok(());
                 } else {
-                    copy_helper(&source, &dest, options, context)?;
+                    copy_helper(
+                        &source,
+                        &dest,
+                        options,
+                        context,
+                        source_is_symlink,
+                        source_is_fifo,
+                        symlinked_files,
+                    )?;
                 }
             } else {
-                copy_helper(&source, &dest, options, context)?;
+                copy_helper(
+                    &source,
+                    &dest,
+                    options,
+                    context,
+                    source_is_symlink,
+                    source_is_fifo,
+                    symlinked_files,
+                )?;
             }
         }
         CopyMode::AttrOnly => {
@@ -1292,7 +1426,13 @@ fn copy_file(source: &Path, dest: &Path, options: &Options) -> CopyResult<()> {
         .map(|meta| !meta.file_type().is_symlink())
         .unwrap_or(false)
     {
-        fs::set_permissions(&dest, dest_permissions).unwrap();
+        // Here, to match GNU semantics, we quietly ignore an error
+        // if a user does not have the correct ownership to modify
+        // the permissions of a file.
+        //
+        // FWIW, the OS will throw an error later, on the write op, if
+        // the user does not have permission to write to the file.
+        fs::set_permissions(&dest, dest_permissions).ok();
     }
     for attribute in &options.preserve_attributes {
         copy_attribute(&source, &dest, attribute)?;
@@ -1302,19 +1442,30 @@ fn copy_file(source: &Path, dest: &Path, options: &Options) -> CopyResult<()> {
 
 /// Copy the file from `source` to `dest` either using the normal `fs::copy` or a
 /// copy-on-write scheme if --reflink is specified and the filesystem supports it.
-fn copy_helper(source: &Path, dest: &Path, options: &Options, context: &str) -> CopyResult<()> {
+fn copy_helper(
+    source: &Path,
+    dest: &Path,
+    options: &Options,
+    context: &str,
+    source_is_symlink: bool,
+    source_is_fifo: bool,
+    symlinked_files: &mut HashSet<FileInformation>,
+) -> CopyResult<()> {
     if options.parents {
         let parent = dest.parent().unwrap_or(dest);
         fs::create_dir_all(parent)?;
     }
-    let is_symlink = fs::symlink_metadata(&source)?.file_type().is_symlink();
+
     if source.as_os_str() == "/dev/null" {
         /* workaround a limitation of fs::copy
          * https://github.com/rust-lang/rust/issues/79390
          */
-        File::create(dest)?;
-    } else if is_symlink {
-        copy_link(source, dest)?;
+        File::create(dest).context(dest.display().to_string())?;
+    } else if source_is_fifo && options.recursive {
+        #[cfg(unix)]
+        copy_fifo(dest, options.overwrite)?;
+    } else if source_is_symlink {
+        copy_link(source, dest, symlinked_files)?;
     } else if options.reflink_mode != ReflinkMode::Never {
         #[cfg(not(any(target_os = "linux", target_os = "macos")))]
         return Err("--reflink is only supported on linux and macOS"
@@ -1332,7 +1483,28 @@ fn copy_helper(source: &Path, dest: &Path, options: &Options, context: &str) ->
     Ok(())
 }
 
-fn copy_link(source: &Path, dest: &Path) -> CopyResult<()> {
+// "Copies" a FIFO by creating a new one. This workaround is because Rust's
+// built-in fs::copy does not handle FIFOs (see rust-lang/rust/issues/79390).
+#[cfg(unix)]
+fn copy_fifo(dest: &Path, overwrite: OverwriteMode) -> CopyResult<()> {
+    if dest.exists() {
+        overwrite.verify(dest)?;
+        fs::remove_file(&dest)?;
+    }
+
+    let name = CString::new(dest.as_os_str().as_bytes()).unwrap();
+    let err = unsafe { mkfifo(name.as_ptr(), 0o666) };
+    if err == -1 {
+        return Err(format!("cannot create fifo {}: File exists", dest.quote()).into());
+    }
+    Ok(())
+}
+
+fn copy_link(
+    source: &Path,
+    dest: &Path,
+    symlinked_files: &mut HashSet<FileInformation>,
+) -> CopyResult<()> {
     // Here, we will copy the symlink itself (actually, just recreate it)
     let link = fs::read_link(&source)?;
     let dest: Cow<'_, Path> = if dest.is_dir() {
@@ -1352,7 +1524,7 @@ fn copy_link(source: &Path, dest: &Path) -> CopyResult<()> {
         }
         dest.into()
     };
-    symlink_file(&link, &dest, &*context_for(&link, &dest))
+    symlink_file(&link, &dest, &*context_for(&link, &dest), symlinked_files)
 }
 
 /// Copies `source` to `dest` using copy-on-write if possible.
@@ -1411,7 +1583,6 @@ fn copy_on_write_macos(
     // Extract paths in a form suitable to be passed to a syscall.
     // The unwrap() is safe because they come from the command-line and so contain non nul
     // character.
-    use std::os::unix::ffi::OsStrExt;
     let src = CString::new(source.as_os_str().as_bytes()).unwrap();
     let dst = CString::new(dest.as_os_str().as_bytes()).unwrap();
 
@@ -1497,6 +1668,13 @@ pub fn paths_refer_to_same_file(p1: &Path, p2: &Path) -> io::Result<bool> {
     Ok(pathbuf1 == pathbuf2)
 }
 
+pub fn path_has_prefix(p1: &Path, p2: &Path) -> io::Result<bool> {
+    let pathbuf1 = canonicalize(p1, MissingHandling::Normal, ResolveMode::Logical)?;
+    let pathbuf2 = canonicalize(p2, MissingHandling::Normal, ResolveMode::Logical)?;
+
+    Ok(pathbuf1.starts_with(pathbuf2))
+}
+
 #[test]
 fn test_cp_localize_to_target() {
     assert!(
@@ -1507,5 +1685,5 @@ fn test_cp_localize_to_target() {
         )
         .unwrap()
             == Path::new("target/c.txt")
-    )
+    );
 }
diff --git a/src/uu/cp/src/main.rs b/src/uu/cp/src/main.rs
index acfcfd1b2..920615e70 100644
--- a/src/uu/cp/src/main.rs
+++ b/src/uu/cp/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_cp);
+uucore::bin!(uu_cp);
diff --git a/src/uu/csplit/Cargo.toml b/src/uu/csplit/Cargo.toml
index b76e942ee..5c9ae227a 100644
--- a/src/uu/csplit/Cargo.toml
+++ b/src/uu/csplit/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_csplit"
-version = "0.0.8"
+version = "0.0.13"
 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"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/ls"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ls"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,16 +15,11 @@ edition = "2018"
 path = "src/csplit.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 thiserror = "1.0"
 regex = "1.0.0"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries", "fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries", "fs"] }
 
 [[bin]]
 name = "csplit"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/csplit/LICENSE b/src/uu/csplit/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/csplit/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/csplit/src/csplit.rs b/src/uu/csplit/src/csplit.rs
index 0d99154df..a0b739935 100644
--- a/src/uu/csplit/src/csplit.rs
+++ b/src/uu/csplit/src/csplit.rs
@@ -1,16 +1,22 @@
 #![crate_name = "uu_csplit"]
+// spell-checker:ignore rustdoc
+#![allow(rustdoc::private_intra_doc_links)]
 
 #[macro_use]
 extern crate uucore;
-use clap::{crate_version, App, Arg, ArgMatches};
-use regex::Regex;
+
 use std::cmp::Ordering;
 use std::io::{self, BufReader};
 use std::{
     fs::{remove_file, File},
     io::{BufRead, BufWriter, Write},
 };
+
+use clap::{crate_version, Arg, ArgMatches, Command};
+use regex::Regex;
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 mod csplit_error;
 mod patterns;
@@ -18,10 +24,10 @@ mod split_name;
 
 use crate::csplit_error::CsplitError;
 use crate::split_name::SplitName;
-use uucore::InvalidEncodingHandling;
 
 static SUMMARY: &str = "split a file into sections determined by context lines";
 static LONG_HELP: &str = "Output pieces of FILE separated by PATTERN(s) to files 'xx00', 'xx01', ..., and output byte counts of each piece to standard output.";
+const USAGE: &str = "{} [OPTION]... FILE PATTERN...";
 
 mod options {
     pub const SUFFIX_FORMAT: &str = "suffix-format";
@@ -35,13 +41,6 @@ mod options {
     pub const PATTERN: &str = "pattern";
 }
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... FILE PATTERN...",
-        uucore::execution_phrase()
-    )
-}
-
 /// Command line options for csplit.
 pub struct CsplitOptions {
     split_name: crate::SplitName,
@@ -52,13 +51,13 @@ pub struct CsplitOptions {
 }
 
 impl CsplitOptions {
-    fn new(matches: &ArgMatches) -> CsplitOptions {
+    fn new(matches: &ArgMatches) -> Self {
         let keep_files = matches.is_present(options::KEEP_FILES);
         let quiet = matches.is_present(options::QUIET);
         let elide_empty_files = matches.is_present(options::ELIDE_EMPTY_FILES);
         let suppress_matched = matches.is_present(options::SUPPRESS_MATCHED);
 
-        CsplitOptions {
+        Self {
             split_name: crash_if_err!(
                 1,
                 SplitName::new(
@@ -80,12 +79,12 @@ impl CsplitOptions {
 /// # Errors
 ///
 /// - [`io::Error`] if there is some problem reading/writing from/to a file.
-/// - [`::CsplitError::LineOutOfRange`] if the line number pattern is larger than the number of input
+/// - [`CsplitError::LineOutOfRange`] if the line number pattern is larger than the number of input
 ///   lines.
-/// - [`::CsplitError::LineOutOfRangeOnRepetition`], like previous but after applying the pattern
+/// - [`CsplitError::LineOutOfRangeOnRepetition`], like previous but after applying the pattern
 ///   more than once.
-/// - [`::CsplitError::MatchNotFound`] if no line matched a regular expression.
-/// - [`::CsplitError::MatchNotFoundOnRepetition`], like previous but after applying the pattern
+/// - [`CsplitError::MatchNotFound`] if no line matched a regular expression.
+/// - [`CsplitError::MatchNotFoundOnRepetition`], like previous but after applying the pattern
 ///   more than once.
 pub fn csplit<T>(
     options: &CsplitOptions,
@@ -103,9 +102,9 @@ where
     input_iter.rewind_buffer();
     if let Some((_, line)) = input_iter.next() {
         split_writer.new_writer()?;
-        split_writer.writeln(line?)?;
+        split_writer.writeln(&line?)?;
         for (_, line) in input_iter {
-            split_writer.writeln(line?)?;
+            split_writer.writeln(&line?)?;
         }
         split_writer.finish_split();
     }
@@ -240,12 +239,12 @@ impl<'a> SplitWriter<'a> {
     }
 
     /// Writes the line to the current split, appending a newline character.
-    /// If [`dev_null`] is true, then the line is discarded.
+    /// If [`self.dev_null`] is true, then the line is discarded.
     ///
     /// # Errors
     ///
     /// Some [`io::Error`] may occur when attempting to write the line.
-    fn writeln(&mut self, line: String) -> io::Result<()> {
+    fn writeln(&mut self, line: &str) -> io::Result<()> {
         if !self.dev_null {
             match self.current_writer {
                 Some(ref mut current_writer) => {
@@ -261,8 +260,8 @@ impl<'a> SplitWriter<'a> {
     }
 
     /// Perform some operations after completing a split, i.e., either remove it
-    /// if the [`::ELIDE_EMPTY_FILES_OPT`] option is enabled, or print how much bytes were written
-    /// to it if [`::QUIET_OPT`] is disabled.
+    /// if the [`options::ELIDE_EMPTY_FILES`] option is enabled, or print how much bytes were written
+    /// to it if [`options::QUIET`] is disabled.
     ///
     /// # Errors
     ///
@@ -302,7 +301,7 @@ impl<'a> SplitWriter<'a> {
     ///
     /// In addition to errors reading/writing from/to a file, if the line number
     /// `n` is greater than the total available lines, then a
-    /// [`::CsplitError::LineOutOfRange`] error is returned.
+    /// [`CsplitError::LineOutOfRange`] error is returned.
     fn do_to_line<I>(
         &mut self,
         pattern_as_str: &str,
@@ -338,7 +337,7 @@ impl<'a> SplitWriter<'a> {
                 }
                 Ordering::Greater => (),
             }
-            self.writeln(l)?;
+            self.writeln(&l)?;
         }
         self.finish_split();
         ret
@@ -351,9 +350,9 @@ impl<'a> SplitWriter<'a> {
     /// # Errors
     ///
     /// In addition to errors reading/writing from/to a file, the following errors may be returned:
-    /// - if no line matched, an [`::CsplitError::MatchNotFound`].
+    /// - if no line matched, an [`CsplitError::MatchNotFound`].
     /// - if there are not enough lines to accommodate the offset, an
-    /// [`::CsplitError::LineOutOfRange`].
+    /// [`CsplitError::LineOutOfRange`].
     fn do_to_match<I>(
         &mut self,
         pattern_as_str: &str,
@@ -368,7 +367,7 @@ impl<'a> SplitWriter<'a> {
             // The offset is zero or positive, no need for a buffer on the lines read.
             // NOTE: drain the buffer of input_iter, no match should be done within.
             for line in input_iter.drain_buffer() {
-                self.writeln(line)?;
+                self.writeln(&line)?;
             }
             // retain the matching line
             input_iter.set_size_of_buffer(1);
@@ -385,7 +384,7 @@ impl<'a> SplitWriter<'a> {
                             );
                         }
                         // a positive offset, some more lines need to be added to the current split
-                        (false, _) => self.writeln(l)?,
+                        (false, _) => self.writeln(&l)?,
                         _ => (),
                     };
                     offset -= 1;
@@ -394,7 +393,7 @@ impl<'a> SplitWriter<'a> {
                     while offset > 0 {
                         match input_iter.next() {
                             Some((_, line)) => {
-                                self.writeln(line?)?;
+                                self.writeln(&line?)?;
                             }
                             None => {
                                 self.finish_split();
@@ -408,7 +407,7 @@ impl<'a> SplitWriter<'a> {
                     self.finish_split();
                     return Ok(());
                 }
-                self.writeln(l)?;
+                self.writeln(&l)?;
             }
         } else {
             // With a negative offset we use a buffer to keep the lines within the offset.
@@ -422,7 +421,7 @@ impl<'a> SplitWriter<'a> {
                 let l = line?;
                 if regex.is_match(&l) {
                     for line in input_iter.shrink_buffer_to_size() {
-                        self.writeln(line)?;
+                        self.writeln(&line)?;
                     }
                     if !self.options.suppress_matched {
                         // add 1 to the buffer size to make place for the matched line
@@ -439,12 +438,12 @@ impl<'a> SplitWriter<'a> {
                     return Ok(());
                 }
                 if let Some(line) = input_iter.add_line_to_buffer(ln, l) {
-                    self.writeln(line)?;
+                    self.writeln(&line)?;
                 }
             }
             // no match, drain the buffer into the current split
             for line in input_iter.drain_buffer() {
-                self.writeln(line)?;
+                self.writeln(&line)?;
             }
         }
 
@@ -472,8 +471,8 @@ impl<I> InputSplitter<I>
 where
     I: Iterator<Item = (usize, io::Result<String>)>,
 {
-    fn new(iter: I) -> InputSplitter<I> {
-        InputSplitter {
+    fn new(iter: I) -> Self {
+        Self {
             iter,
             buffer: Vec::new(),
             rewind: false,
@@ -509,7 +508,7 @@ where
         self.size = size;
     }
 
-    /// Add a line to the buffer. If the buffer has [`size`] elements, then its head is removed and
+    /// Add a line to the buffer. If the buffer has [`self.size`] elements, then its head is removed and
     /// the new line is pushed to the buffer. The removed head is then available in the returned
     /// option.
     fn add_line_to_buffer(&mut self, ln: usize, line: String) -> Option<String> {
@@ -712,13 +711,13 @@ mod tests {
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     // get the file to split
     let file_name = matches.value_of(options::FILE).unwrap();
@@ -729,76 +728,80 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         .unwrap()
         .map(str::to_string)
         .collect();
-    let patterns = crash_if_err!(1, patterns::get_patterns(&patterns[..]));
+    let patterns = patterns::get_patterns(&patterns[..])?;
     let options = CsplitOptions::new(&matches);
     if file_name == "-" {
         let stdin = io::stdin();
-        crash_if_err!(1, csplit(&options, patterns, stdin.lock()));
+        Ok(csplit(&options, patterns, stdin.lock())?)
     } else {
-        let file = crash_if_err!(1, File::open(file_name));
-        let file_metadata = crash_if_err!(1, file.metadata());
+        let file = File::open(file_name)
+            .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
+        let file_metadata = file
+            .metadata()
+            .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
         if !file_metadata.is_file() {
-            crash!(1, "{} is not a regular file", file_name.quote());
+            return Err(CsplitError::NotRegularFile(file_name.to_string()).into());
         }
-        crash_if_err!(1, csplit(&options, patterns, BufReader::new(file)));
-    };
-    0
+        Ok(csplit(&options, patterns, BufReader::new(file))?)
+    }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(SUMMARY)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::SUFFIX_FORMAT)
-                .short("b")
+            Arg::new(options::SUFFIX_FORMAT)
+                .short('b')
                 .long(options::SUFFIX_FORMAT)
                 .value_name("FORMAT")
                 .help("use sprintf FORMAT instead of %02d"),
         )
         .arg(
-            Arg::with_name(options::PREFIX)
-                .short("f")
+            Arg::new(options::PREFIX)
+                .short('f')
                 .long(options::PREFIX)
                 .value_name("PREFIX")
                 .help("use PREFIX instead of 'xx'"),
         )
         .arg(
-            Arg::with_name(options::KEEP_FILES)
-                .short("k")
+            Arg::new(options::KEEP_FILES)
+                .short('k')
                 .long(options::KEEP_FILES)
                 .help("do not remove output files on errors"),
         )
         .arg(
-            Arg::with_name(options::SUPPRESS_MATCHED)
+            Arg::new(options::SUPPRESS_MATCHED)
                 .long(options::SUPPRESS_MATCHED)
                 .help("suppress the lines matching PATTERN"),
         )
         .arg(
-            Arg::with_name(options::DIGITS)
-                .short("n")
+            Arg::new(options::DIGITS)
+                .short('n')
                 .long(options::DIGITS)
                 .value_name("DIGITS")
                 .help("use specified number of digits instead of 2"),
         )
         .arg(
-            Arg::with_name(options::QUIET)
-                .short("s")
+            Arg::new(options::QUIET)
+                .short('s')
                 .long(options::QUIET)
                 .visible_alias("silent")
                 .help("do not print counts of output file sizes"),
         )
         .arg(
-            Arg::with_name(options::ELIDE_EMPTY_FILES)
-                .short("z")
+            Arg::new(options::ELIDE_EMPTY_FILES)
+                .short('z')
                 .long(options::ELIDE_EMPTY_FILES)
                 .help("remove empty output files"),
         )
-        .arg(Arg::with_name(options::FILE).hidden(true).required(true))
+        .arg(Arg::new(options::FILE).hide(true).required(true))
         .arg(
-            Arg::with_name(options::PATTERN)
-                .hidden(true)
-                .multiple(true)
+            Arg::new(options::PATTERN)
+                .hide(true)
+                .multiple_occurrences(true)
                 .required(true),
         )
         .after_help(LONG_HELP)
diff --git a/src/uu/csplit/src/csplit_error.rs b/src/uu/csplit/src/csplit_error.rs
index 1d4823ee2..b81a331a2 100644
--- a/src/uu/csplit/src/csplit_error.rs
+++ b/src/uu/csplit/src/csplit_error.rs
@@ -2,6 +2,7 @@ use std::io;
 use thiserror::Error;
 
 use uucore::display::Quotable;
+use uucore::error::UError;
 
 /// Errors thrown by the csplit command
 #[derive(Debug, Error)]
@@ -28,10 +29,18 @@ pub enum CsplitError {
     SuffixFormatIncorrect,
     #[error("too many % conversion specifications in suffix")]
     SuffixFormatTooManyPercents,
+    #[error("{} is not a regular file", ._0.quote())]
+    NotRegularFile(String),
 }
 
 impl From<io::Error> for CsplitError {
     fn from(error: io::Error) -> Self {
-        CsplitError::IoError(error)
+        Self::IoError(error)
+    }
+}
+
+impl UError for CsplitError {
+    fn code(&self) -> i32 {
+        1
     }
 }
diff --git a/src/uu/csplit/src/main.rs b/src/uu/csplit/src/main.rs
index b0b144e8c..1ada30007 100644
--- a/src/uu/csplit/src/main.rs
+++ b/src/uu/csplit/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_csplit);
+uucore::bin!(uu_csplit);
diff --git a/src/uu/csplit/src/patterns.rs b/src/uu/csplit/src/patterns.rs
index 4ab7862ac..0346ed381 100644
--- a/src/uu/csplit/src/patterns.rs
+++ b/src/uu/csplit/src/patterns.rs
@@ -44,8 +44,8 @@ pub enum ExecutePattern {
 impl ExecutePattern {
     pub fn iter(&self) -> ExecutePatternIter {
         match self {
-            ExecutePattern::Times(n) => ExecutePatternIter::new(Some(*n)),
-            ExecutePattern::Always => ExecutePatternIter::new(None),
+            Self::Times(n) => ExecutePatternIter::new(Some(*n)),
+            Self::Always => ExecutePatternIter::new(None),
         }
     }
 }
@@ -56,8 +56,8 @@ pub struct ExecutePatternIter {
 }
 
 impl ExecutePatternIter {
-    fn new(max: Option<usize>) -> ExecutePatternIter {
-        ExecutePatternIter { max, cur: 0 }
+    fn new(max: Option<usize>) -> Self {
+        Self { max, cur: 0 }
     }
 }
 
@@ -88,7 +88,7 @@ impl Iterator for ExecutePatternIter {
 ///
 /// # Errors
 ///
-/// If a pattern is incorrect, a [`::CsplitError::InvalidPattern`] error is returned, which may be
+/// If a pattern is incorrect, a [`CsplitError::InvalidPattern`] error is returned, which may be
 /// due to, e.g.,:
 /// - an invalid regular expression;
 /// - an invalid number for, e.g., the offset.
diff --git a/src/uu/csplit/src/split_name.rs b/src/uu/csplit/src/split_name.rs
index 44ea2a5af..b1f4f1505 100644
--- a/src/uu/csplit/src/split_name.rs
+++ b/src/uu/csplit/src/split_name.rs
@@ -29,7 +29,7 @@ impl SplitName {
         prefix_opt: Option<String>,
         format_opt: Option<String>,
         n_digits_opt: Option<String>,
-    ) -> Result<SplitName, CsplitError> {
+    ) -> Result<Self, CsplitError> {
         // get the prefix
         let prefix = prefix_opt.unwrap_or_else(|| "xx".to_string());
         // the width for the split offset
@@ -231,7 +231,7 @@ impl SplitName {
             }
         };
 
-        Ok(SplitName { fn_split_name })
+        Ok(Self { fn_split_name })
     }
 
     /// Returns the filename of the i-th split.
diff --git a/src/uu/cut/Cargo.toml b/src/uu/cut/Cargo.toml
index 991e3c449..3f800a786 100644
--- a/src/uu/cut/Cargo.toml
+++ b/src/uu/cut/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_cut"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "cut ~ (uutils) display byte/field columns of input lines"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/cut"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cut"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/cut.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 memchr = "2"
 bstr = "0.2"
 atty = "0.2"
@@ -25,7 +24,3 @@ atty = "0.2"
 [[bin]]
 name = "cut"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/cut/LICENSE b/src/uu/cut/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/cut/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/cut/src/cut.rs b/src/uu/cut/src/cut.rs
index 35d92b83f..2264f4f26 100644
--- a/src/uu/cut/src/cut.rs
+++ b/src/uu/cut/src/cut.rs
@@ -11,21 +11,22 @@
 extern crate uucore;
 
 use bstr::io::BufReadExt;
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::File;
 use std::io::{stdin, stdout, BufReader, BufWriter, Read, Write};
 use std::path::Path;
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult, USimpleError};
 
 use self::searcher::Searcher;
 use uucore::ranges::Range;
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 mod searcher;
 
 static NAME: &str = "cut";
-static SYNTAX: &str =
-    "[-d] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+";
+static USAGE: &str =
+    "{} [-d] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+";
 static SUMMARY: &str =
     "Prints specified byte or field columns from each line of stdin or the input files";
 static LONG_HELP: &str = "
@@ -142,7 +143,7 @@ fn list_to_ranges(list: &str, complement: bool) -> Result<Vec<Range>, String> {
     }
 }
 
-fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> i32 {
+fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()> {
     let newline_char = if opts.zero_terminated { b'\0' } else { b'\n' };
     let buf_in = BufReader::new(reader);
     let mut out = stdout_writer();
@@ -152,7 +153,7 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> i32 {
         .map_or("", String::as_str)
         .as_bytes();
 
-    let res = buf_in.for_byte_record(newline_char, |line| {
+    let result = buf_in.for_byte_record(newline_char, |line| {
         let mut print_delim = false;
         for &Range { low, high } in ranges {
             if low > line.len() {
@@ -171,8 +172,12 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> i32 {
         out.write_all(&[newline_char])?;
         Ok(true)
     });
-    crash_if_err!(1, res);
-    0
+
+    if let Err(e) = result {
+        return Err(USimpleError::new(1, e.to_string()));
+    }
+
+    Ok(())
 }
 
 #[allow(clippy::cognitive_complexity)]
@@ -183,7 +188,7 @@ fn cut_fields_delimiter<R: Read>(
     only_delimited: bool,
     newline_char: u8,
     out_delim: &str,
-) -> i32 {
+) -> UResult<()> {
     let buf_in = BufReader::new(reader);
     let mut out = stdout_writer();
     let input_delim_len = delim.len();
@@ -246,12 +251,16 @@ fn cut_fields_delimiter<R: Read>(
         out.write_all(&[newline_char])?;
         Ok(true)
     });
-    crash_if_err!(1, result);
-    0
+
+    if let Err(e) = result {
+        return Err(USimpleError::new(1, e.to_string()));
+    }
+
+    Ok(())
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> i32 {
+fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> UResult<()> {
     let newline_char = if opts.zero_terminated { b'\0' } else { b'\n' };
     if let Some(ref o_delim) = opts.out_delimiter {
         return cut_fields_delimiter(
@@ -323,13 +332,16 @@ fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> i32
         out.write_all(&[newline_char])?;
         Ok(true)
     });
-    crash_if_err!(1, result);
-    0
+
+    if let Err(e) = result {
+        return Err(USimpleError::new(1, e.to_string()));
+    }
+
+    Ok(())
 }
 
-fn cut_files(mut filenames: Vec<String>, mode: Mode) -> i32 {
+fn cut_files(mut filenames: Vec<String>, mode: &Mode) -> UResult<()> {
     let mut stdin_read = false;
-    let mut exit_code = 0;
 
     if filenames.is_empty() {
         filenames.push("-".to_owned());
@@ -341,11 +353,11 @@ fn cut_files(mut filenames: Vec<String>, mode: Mode) -> i32 {
                 continue;
             }
 
-            exit_code |= match mode {
+            show_if_err!(match mode {
                 Mode::Bytes(ref ranges, ref opts) => cut_bytes(stdin(), ranges, opts),
                 Mode::Characters(ref ranges, ref opts) => cut_bytes(stdin(), ranges, opts),
                 Mode::Fields(ref ranges, ref opts) => cut_fields(stdin(), ranges, opts),
-            };
+            });
 
             stdin_read = true;
         } else {
@@ -356,28 +368,20 @@ fn cut_files(mut filenames: Vec<String>, mode: Mode) -> i32 {
                 continue;
             }
 
-            if path.metadata().is_err() {
-                show_error!("{}: No such file or directory", filename.maybe_quote());
-                continue;
-            }
-
-            let file = match File::open(&path) {
-                Ok(f) => f,
-                Err(e) => {
-                    show_error!("opening {}: {}", filename.quote(), e);
-                    continue;
-                }
-            };
-
-            exit_code |= match mode {
-                Mode::Bytes(ref ranges, ref opts) => cut_bytes(file, ranges, opts),
-                Mode::Characters(ref ranges, ref opts) => cut_bytes(file, ranges, opts),
-                Mode::Fields(ref ranges, ref opts) => cut_fields(file, ranges, opts),
-            };
+            show_if_err!(File::open(&path)
+                .map_err_context(|| filename.maybe_quote().to_string())
+                .and_then(|file| {
+                    match &mode {
+                        Mode::Bytes(ranges, opts) | Mode::Characters(ranges, opts) => {
+                            cut_bytes(file, ranges, opts)
+                        }
+                        Mode::Fields(ranges, opts) => cut_fields(file, ranges, opts),
+                    }
+                }));
         }
     }
 
-    exit_code
+    Ok(())
 }
 
 mod options {
@@ -392,7 +396,8 @@ mod options {
     pub const FILE: &str = "file";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
@@ -462,12 +467,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                             delim = "=";
                         }
                         if delim.chars().count() > 1 {
-                            Err(msg_opt_invalid_should_be!(
-                                "empty or 1 character long",
-                                "a value 2 characters or longer",
-                                "--delimiter",
-                                "-d"
-                            ))
+                            Err("invalid input: The '--delimiter' ('-d') option expects empty or 1 character long, but was provided a value 2 characters or longer".into())
                         } else {
                             let delim = if delim.is_empty() {
                                 "\0".to_owned()
@@ -499,13 +499,9 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             })
         }
         (ref b, ref c, ref f) if b.is_some() || c.is_some() || f.is_some() => Err(
-            msg_expects_no_more_than_one_of!("--fields (-f)", "--chars (-c)", "--bytes (-b)"),
+            "invalid usage: expects no more than one of --fields (-f), --chars (-c) or --bytes (-b)".into()
         ),
-        _ => Err(msg_expects_one_of!(
-            "--fields (-f)",
-            "--chars (-c)",
-            "--bytes (-b)"
-        )),
+        _ => Err("invalid usage: expects one of --fields (-f), --chars (-c) or --bytes (-b)".into()),
     };
 
     let mode_parse = match mode_parse {
@@ -514,20 +510,12 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             Mode::Bytes(_, _) | Mode::Characters(_, _)
                 if matches.is_present(options::DELIMITER) =>
             {
-                Err(msg_opt_only_usable_if!(
-                    "printing a sequence of fields",
-                    "--delimiter",
-                    "-d"
-                ))
+                Err("invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields".into())
             }
             Mode::Bytes(_, _) | Mode::Characters(_, _)
                 if matches.is_present(options::ONLY_DELIMITED) =>
             {
-                Err(msg_opt_only_usable_if!(
-                    "printing a sequence of fields",
-                    "--only-delimited",
-                    "-s"
-                ))
+                Err("invalid input: The '--only-delimited' ('-s') option only usable if printing a sequence of fields".into())
             }
             _ => Ok(mode),
         },
@@ -540,24 +528,22 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         .collect();
 
     match mode_parse {
-        Ok(mode) => cut_files(files, mode),
-        Err(err_msg) => {
-            show_error!("{}", err_msg);
-            1
-        }
+        Ok(mode) => cut_files(files, &mode),
+        Err(e) => Err(USimpleError::new(1, e)),
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(SYNTAX)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
         .after_help(LONG_HELP)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BYTES)
-                .short("b")
+            Arg::new(options::BYTES)
+                .short('b')
                 .long(options::BYTES)
                 .takes_value(true)
                 .help("filter byte columns from the input source")
@@ -566,8 +552,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .display_order(1),
         )
         .arg(
-            Arg::with_name(options::CHARACTERS)
-                .short("c")
+            Arg::new(options::CHARACTERS)
+                .short('c')
                 .long(options::CHARACTERS)
                 .help("alias for character mode")
                 .takes_value(true)
@@ -576,8 +562,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .display_order(2),
         )
         .arg(
-            Arg::with_name(options::DELIMITER)
-                .short("d")
+            Arg::new(options::DELIMITER)
+                .short('d')
                 .long(options::DELIMITER)
                 .help("specify the delimiter character that separates fields in the input source. Defaults to Tab.")
                 .takes_value(true)
@@ -585,8 +571,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .display_order(3),
         )
         .arg(
-            Arg::with_name(options::FIELDS)
-                .short("f")
+            Arg::new(options::FIELDS)
+                .short('f')
                 .long(options::FIELDS)
                 .help("filter field columns from the input source")
                 .takes_value(true)
@@ -595,30 +581,30 @@ pub fn uu_app() -> App<'static, 'static> {
                 .display_order(4),
         )
         .arg(
-            Arg::with_name(options::COMPLEMENT)
+            Arg::new(options::COMPLEMENT)
                 .long(options::COMPLEMENT)
                 .help("invert the filter - instead of displaying only the filtered columns, display all but those columns")
                 .takes_value(false)
                 .display_order(5),
         )
         .arg(
-            Arg::with_name(options::ONLY_DELIMITED)
-            .short("s")
+            Arg::new(options::ONLY_DELIMITED)
+            .short('s')
                 .long(options::ONLY_DELIMITED)
                 .help("in field mode, only print lines which contain the delimiter")
                 .takes_value(false)
                 .display_order(6),
         )
         .arg(
-            Arg::with_name(options::ZERO_TERMINATED)
-            .short("z")
+            Arg::new(options::ZERO_TERMINATED)
+            .short('z')
                 .long(options::ZERO_TERMINATED)
                 .help("instead of filtering columns based on line, filter columns based on \\0 (NULL character)")
                 .takes_value(false)
                 .display_order(8),
         )
         .arg(
-            Arg::with_name(options::OUTPUT_DELIMITER)
+            Arg::new(options::OUTPUT_DELIMITER)
             .long(options::OUTPUT_DELIMITER)
                 .help("in field mode, replace the delimiter in output lines with this option's argument")
                 .takes_value(true)
@@ -626,8 +612,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .display_order(7),
         )
         .arg(
-            Arg::with_name(options::FILE)
-            .hidden(true)
-                .multiple(true)
+            Arg::new(options::FILE)
+            .hide(true)
+                .multiple_occurrences(true)
         )
 }
diff --git a/src/uu/cut/src/main.rs b/src/uu/cut/src/main.rs
index 8822335f6..2f000a7f3 100644
--- a/src/uu/cut/src/main.rs
+++ b/src/uu/cut/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_cut);
+uucore::bin!(uu_cut);
diff --git a/src/uu/cut/src/searcher.rs b/src/uu/cut/src/searcher.rs
index 5fe4a723b..d8a040451 100644
--- a/src/uu/cut/src/searcher.rs
+++ b/src/uu/cut/src/searcher.rs
@@ -72,7 +72,7 @@ mod tests {
         assert_eq!(vec![] as Vec<usize>, items);
     }
 
-    fn test_multibyte(line: &[u8], expected: Vec<usize>) {
+    fn test_multibyte(line: &[u8], expected: &[usize]) {
         let iter = Searcher::new(line, NEEDLE);
         let items: Vec<usize> = iter.collect();
         assert_eq!(expected, items);
@@ -80,26 +80,26 @@ mod tests {
 
     #[test]
     fn test_multibyte_normal() {
-        test_multibyte("...ab...ab...".as_bytes(), vec![3, 8]);
+        test_multibyte("...ab...ab...".as_bytes(), &[3, 8]);
     }
 
     #[test]
     fn test_multibyte_needle_head_at_end() {
-        test_multibyte("a".as_bytes(), vec![]);
+        test_multibyte("a".as_bytes(), &[]);
     }
 
     #[test]
     fn test_multibyte_starting_needle() {
-        test_multibyte("ab...ab...".as_bytes(), vec![0, 5]);
+        test_multibyte("ab...ab...".as_bytes(), &[0, 5]);
     }
 
     #[test]
     fn test_multibyte_trailing_needle() {
-        test_multibyte("...ab...ab".as_bytes(), vec![3, 8]);
+        test_multibyte("...ab...ab".as_bytes(), &[3, 8]);
     }
 
     #[test]
     fn test_multibyte_first_byte_false_match() {
-        test_multibyte("aA..aCaC..ab..aD".as_bytes(), vec![10]);
+        test_multibyte("aA..aCaC..ab..aD".as_bytes(), &[10]);
     }
 }
diff --git a/src/uu/date/Cargo.toml b/src/uu/date/Cargo.toml
index b1077fbe1..a73a04d1b 100644
--- a/src/uu/date/Cargo.toml
+++ b/src/uu/date/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_date"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "date ~ (uutils) display or set the current time"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/date"
+repository = "https://github.com/uutils/coreutils/tree/main/src/date"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/date.rs"
 
 [dependencies]
-chrono = "0.4.4"
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+chrono = "^0.4.11"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
@@ -29,7 +28,3 @@ winapi = { version = "0.3", features = ["minwinbase", "sysinfoapi", "minwindef"]
 [[bin]]
 name = "date"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/date/LICENSE b/src/uu/date/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/date/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/date/src/date.rs b/src/uu/date/src/date.rs
index adcf77024..8946768d5 100644
--- a/src/uu/date/src/date.rs
+++ b/src/uu/date/src/date.rs
@@ -11,14 +11,17 @@
 use chrono::{DateTime, FixedOffset, Local, Offset, Utc};
 #[cfg(windows)]
 use chrono::{Datelike, Timelike};
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 #[cfg(all(unix, not(target_os = "macos"), not(target_os = "redox")))]
 use libc::{clock_settime, timespec, CLOCK_REALTIME};
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 use uucore::display::Quotable;
-use uucore::show_error;
+#[cfg(not(any(target_os = "macos", target_os = "redox")))]
+use uucore::error::FromIo;
+use uucore::error::{UResult, USimpleError};
+use uucore::{format_usage, show_error};
 #[cfg(windows)]
 use winapi::{
     shared::minwindef::WORD,
@@ -35,8 +38,10 @@ const MINUTE: &str = "minute";
 const SECOND: &str = "second";
 const NS: &str = "ns";
 
-const NAME: &str = "date";
 const ABOUT: &str = "print or set the system date and time";
+const USAGE: &str = "\
+    {} [OPTION]... [+FORMAT]...
+    {} [OPTION]... [MMDDhhmm[[CC]YY][.ss]]";
 
 const OPT_DATE: &str = "date";
 const OPT_FORMAT: &str = "format";
@@ -108,11 +113,11 @@ enum Iso8601Format {
 impl<'a> From<&'a str> for Iso8601Format {
     fn from(s: &str) -> Self {
         match s {
-            HOURS | HOUR => Iso8601Format::Hours,
-            MINUTES | MINUTE => Iso8601Format::Minutes,
-            SECONDS | SECOND => Iso8601Format::Seconds,
-            NS => Iso8601Format::Ns,
-            DATE => Iso8601Format::Date,
+            HOURS | HOUR => Self::Hours,
+            MINUTES | MINUTE => Self::Minutes,
+            SECONDS | SECOND => Self::Seconds,
+            NS => Self::Ns,
+            DATE => Self::Date,
             // Should be caught by clap
             _ => panic!("Invalid format: {}", s),
         }
@@ -128,27 +133,25 @@ enum Rfc3339Format {
 impl<'a> From<&'a str> for Rfc3339Format {
     fn from(s: &str) -> Self {
         match s {
-            DATE => Rfc3339Format::Date,
-            SECONDS | SECOND => Rfc3339Format::Seconds,
-            NS => Rfc3339Format::Ns,
+            DATE => Self::Date,
+            SECONDS | SECOND => Self::Seconds,
+            NS => Self::Ns,
             // Should be caught by clap
             _ => panic!("Invalid format: {}", s),
         }
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let syntax = format!(
-        "{0} [OPTION]... [+FORMAT]...
- {0} [OPTION]... [MMDDhhmm[[CC]YY][.ss]]",
-        NAME
-    );
-    let matches = uu_app().usage(&syntax[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let format = if let Some(form) = matches.value_of(OPT_FORMAT) {
         if !form.starts_with('+') {
-            show_error!("invalid date {}", form.quote());
-            return 1;
+            return Err(USimpleError::new(
+                1,
+                format!("invalid date {}", form.quote()),
+            ));
         }
         let form = form[1..].to_string();
         Format::Custom(form)
@@ -176,8 +179,10 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     let set_to = match matches.value_of(OPT_SET).map(parse_date) {
         None => None,
         Some(Err((input, _err))) => {
-            show_error!("invalid date {}", input.quote());
-            return 1;
+            return Err(USimpleError::new(
+                1,
+                format!("invalid date {}", input.quote()),
+            ));
         }
         Some(Ok(date)) => Some(date),
     };
@@ -241,80 +246,80 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                     let formatted = date.format(format_string).to_string().replace("%f", "%N");
                     println!("{}", formatted);
                 }
-                Err((input, _err)) => {
-                    show_error!("invalid date {}", input.quote());
-                }
+                Err((input, _err)) => show_error!("invalid date {}", input.quote()),
             }
         }
     }
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_DATE)
-                .short("d")
+            Arg::new(OPT_DATE)
+                .short('d')
                 .long(OPT_DATE)
                 .takes_value(true)
                 .help("display time described by STRING, not 'now'"),
         )
         .arg(
-            Arg::with_name(OPT_FILE)
-                .short("f")
+            Arg::new(OPT_FILE)
+                .short('f')
                 .long(OPT_FILE)
                 .takes_value(true)
                 .help("like --date; once for each line of DATEFILE"),
         )
         .arg(
-            Arg::with_name(OPT_ISO_8601)
-                .short("I")
+            Arg::new(OPT_ISO_8601)
+                .short('I')
                 .long(OPT_ISO_8601)
                 .takes_value(true)
                 .help(ISO_8601_HELP_STRING),
         )
         .arg(
-            Arg::with_name(OPT_RFC_EMAIL)
-                .short("R")
+            Arg::new(OPT_RFC_EMAIL)
+                .short('R')
                 .long(OPT_RFC_EMAIL)
                 .help(RFC_5322_HELP_STRING),
         )
         .arg(
-            Arg::with_name(OPT_RFC_3339)
+            Arg::new(OPT_RFC_3339)
                 .long(OPT_RFC_3339)
                 .takes_value(true)
                 .help(RFC_3339_HELP_STRING),
         )
         .arg(
-            Arg::with_name(OPT_DEBUG)
+            Arg::new(OPT_DEBUG)
                 .long(OPT_DEBUG)
                 .help("annotate the parsed date, and warn about questionable usage to stderr"),
         )
         .arg(
-            Arg::with_name(OPT_REFERENCE)
-                .short("r")
+            Arg::new(OPT_REFERENCE)
+                .short('r')
                 .long(OPT_REFERENCE)
                 .takes_value(true)
                 .help("display the last modification time of FILE"),
         )
         .arg(
-            Arg::with_name(OPT_SET)
-                .short("s")
+            Arg::new(OPT_SET)
+                .short('s')
                 .long(OPT_SET)
                 .takes_value(true)
                 .help(OPT_SET_HELP_STRING),
         )
         .arg(
-            Arg::with_name(OPT_UNIVERSAL)
-                .short("u")
+            Arg::new(OPT_UNIVERSAL)
+                .short('u')
                 .long(OPT_UNIVERSAL)
                 .alias(OPT_UNIVERSAL_2)
                 .help("print or set Coordinated Universal Time (UTC)"),
         )
-        .arg(Arg::with_name(OPT_FORMAT).multiple(false))
+        .arg(Arg::new(OPT_FORMAT).multiple_occurrences(false))
 }
 
 /// Return the appropriate format string for the given settings.
@@ -348,29 +353,33 @@ fn parse_date<S: AsRef<str> + Clone>(
 }
 
 #[cfg(not(any(unix, windows)))]
-fn set_system_datetime(_date: DateTime<Utc>) -> i32 {
+fn set_system_datetime(_date: DateTime<Utc>) -> UResult<()> {
     unimplemented!("setting date not implemented (unsupported target)");
 }
 
 #[cfg(target_os = "macos")]
-fn set_system_datetime(_date: DateTime<Utc>) -> i32 {
-    show_error!("setting the date is not supported by macOS");
-    1
+fn set_system_datetime(_date: DateTime<Utc>) -> UResult<()> {
+    Err(USimpleError::new(
+        1,
+        "setting the date is not supported by macOS".to_string(),
+    ))
 }
 
 #[cfg(target_os = "redox")]
-fn set_system_datetime(_date: DateTime<Utc>) -> i32 {
-    show_error!("setting the date is not supported by Redox");
-    1
+fn set_system_datetime(_date: DateTime<Utc>) -> UResult<()> {
+    Err(USimpleError::new(
+        1,
+        "setting the date is not supported by Redox".to_string(),
+    ))
 }
 
 #[cfg(all(unix, not(target_os = "macos"), not(target_os = "redox")))]
 /// System call to set date (unix).
 /// See here for more:
-/// https://doc.rust-lang.org/libc/i686-unknown-linux-gnu/libc/fn.clock_settime.html
-/// https://linux.die.net/man/3/clock_settime
-/// https://www.gnu.org/software/libc/manual/html_node/Time-Types.html
-fn set_system_datetime(date: DateTime<Utc>) -> i32 {
+/// `<https://doc.rust-lang.org/libc/i686-unknown-linux-gnu/libc/fn.clock_settime.html>`
+/// `<https://linux.die.net/man/3/clock_settime>`
+/// `<https://www.gnu.org/software/libc/manual/html_node/Time-Types.html>`
+fn set_system_datetime(date: DateTime<Utc>) -> UResult<()> {
     let timespec = timespec {
         tv_sec: date.timestamp() as _,
         tv_nsec: date.timestamp_subsec_nanos() as _,
@@ -379,11 +388,9 @@ fn set_system_datetime(date: DateTime<Utc>) -> i32 {
     let result = unsafe { clock_settime(CLOCK_REALTIME, &timespec) };
 
     if result != 0 {
-        let error = std::io::Error::last_os_error();
-        show_error!("cannot set date: {}", error);
-        error.raw_os_error().unwrap()
+        Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
     } else {
-        0
+        Ok(())
     }
 }
 
@@ -392,7 +399,7 @@ fn set_system_datetime(date: DateTime<Utc>) -> i32 {
 /// See here for more:
 /// https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-setsystemtime
 /// https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-systemtime
-fn set_system_datetime(date: DateTime<Utc>) -> i32 {
+fn set_system_datetime(date: DateTime<Utc>) -> UResult<()> {
     let system_time = SYSTEMTIME {
         wYear: date.year() as WORD,
         wMonth: date.month() as WORD,
@@ -409,10 +416,8 @@ fn set_system_datetime(date: DateTime<Utc>) -> i32 {
     let result = unsafe { SetSystemTime(&system_time) };
 
     if result == 0 {
-        let error = std::io::Error::last_os_error();
-        show_error!("cannot set date: {}", error);
-        error.raw_os_error().unwrap()
+        Err(std::io::Error::last_os_error().map_err_context(|| "cannot set date".to_string()))
     } else {
-        0
+        Ok(())
     }
 }
diff --git a/src/uu/date/src/main.rs b/src/uu/date/src/main.rs
index 9064c7f67..7483582de 100644
--- a/src/uu/date/src/main.rs
+++ b/src/uu/date/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_date);
+uucore::bin!(uu_date);
diff --git a/src/uu/dd/Cargo.toml b/src/uu/dd/Cargo.toml
index e26c141cb..da2d43184 100644
--- a/src/uu/dd/Cargo.toml
+++ b/src/uu/dd/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_dd"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dd ~ (uutils) copy and convert files"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/dd"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/dd"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -16,14 +16,10 @@ path = "src/dd.rs"
 
 [dependencies]
 byte-unit = "4.0"
-clap = { version = "2.33", features = [ "wrap_help" ] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 gcd = "2.0"
 libc = "0.2"
 uucore = { version=">=0.0.8", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.5", package="uucore_procs", path="../../uucore_procs" }
-
-[dev-dependencies]
-tempfile = "^3"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 signal-hook = "0.3.9"
@@ -31,7 +27,3 @@ signal-hook = "0.3.9"
 [[bin]]
 name = "dd"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/dd/LICENSE b/src/uu/dd/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/dd/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/dd/src/blocks.rs b/src/uu/dd/src/blocks.rs
new file mode 100644
index 000000000..3f7c59c27
--- /dev/null
+++ b/src/uu/dd/src/blocks.rs
@@ -0,0 +1,384 @@
+//  * 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 datastructures rstat rposition cflags ctable
+
+use crate::conversion_tables::ConversionTable;
+use crate::datastructures::ConversionMode;
+use crate::progress::ReadStat;
+
+const NEWLINE: u8 = b'\n';
+const SPACE: u8 = b' ';
+
+/// Split a slice into chunks, padding or truncating as necessary.
+///
+/// The slice `buf` is split on newlines, then each block is resized
+/// to `cbs` bytes, padding with spaces if necessary. This function
+/// expects the input bytes to be ASCII-encoded.
+///
+/// If `sync` is true and there has been at least one partial record
+/// read from the input (as indicated in `rstat`), then leave an
+/// all-spaces block at the end. Otherwise, remove the last block if
+/// it is all spaces.
+fn block(buf: &[u8], cbs: usize, sync: bool, rstat: &mut ReadStat) -> Vec<Vec<u8>> {
+    let mut blocks = buf
+        .split(|&e| e == NEWLINE)
+        .map(|split| split.to_vec())
+        .fold(Vec::new(), |mut blocks, mut split| {
+            if split.len() > cbs {
+                rstat.records_truncated += 1;
+            }
+            split.resize(cbs, SPACE);
+            blocks.push(split);
+
+            blocks
+        });
+
+    // If `sync` is true and there has been at least one partial
+    // record read from the input, then leave the all-spaces block at
+    // the end. Otherwise, remove it.
+    if let Some(last) = blocks.last() {
+        if (!sync || rstat.reads_partial == 0) && last.iter().all(|&e| e == SPACE) {
+            blocks.pop();
+        }
+    }
+
+    blocks
+}
+
+/// Trims padding from each cbs-length partition of buf
+/// as specified by conv=unblock and cbs=N
+/// Expects ascii encoded data
+fn unblock(buf: &[u8], cbs: usize) -> Vec<u8> {
+    buf.chunks(cbs).fold(Vec::new(), |mut acc, block| {
+        if let Some(last_char_idx) = block.iter().rposition(|&e| e != SPACE) {
+            // Include text up to last space.
+            acc.extend(&block[..=last_char_idx]);
+        }
+
+        acc.push(NEWLINE);
+        acc
+    })
+}
+
+/// Apply the specified conversion, blocking, and/or unblocking in the right order.
+///
+/// The `mode` specifies the combination of conversion, blocking, and
+/// unblocking to apply and the order in which to apply it. This
+/// function is responsible only for applying the operations.
+///
+/// `buf` is the buffer of input bytes to transform. This function
+/// mutates this input and also returns a new buffer of bytes
+/// representing the result of the transformation.
+///
+/// `rstat` maintains a running total of the number of partial and
+/// complete blocks read before calling this function. In certain
+/// settings of `mode`, this function will update the number of
+/// records truncated; that's why `rstat` is borrowed mutably.
+pub(crate) fn conv_block_unblock_helper(
+    mut buf: Vec<u8>,
+    mode: &ConversionMode,
+    rstat: &mut ReadStat,
+) -> Vec<u8> {
+    // TODO This function has a mutable input `buf` but also returns a
+    // completely new `Vec`; that seems fishy. Could we either make
+    // the input immutable or make the function not return anything?
+
+    fn apply_conversion(buf: &mut [u8], ct: &ConversionTable) {
+        for idx in 0..buf.len() {
+            buf[idx] = ct[buf[idx] as usize];
+        }
+    }
+
+    match mode {
+        ConversionMode::ConvertOnly(ct) => {
+            apply_conversion(&mut buf, ct);
+            buf
+        }
+        ConversionMode::BlockThenConvert(ct, cbs, sync) => {
+            let mut blocks = block(&buf, *cbs, *sync, rstat);
+            for buf in &mut blocks {
+                apply_conversion(buf, ct);
+            }
+            blocks.into_iter().flatten().collect()
+        }
+        ConversionMode::ConvertThenBlock(ct, cbs, sync) => {
+            apply_conversion(&mut buf, ct);
+            block(&buf, *cbs, *sync, rstat)
+                .into_iter()
+                .flatten()
+                .collect()
+        }
+        ConversionMode::BlockOnly(cbs, sync) => block(&buf, *cbs, *sync, rstat)
+            .into_iter()
+            .flatten()
+            .collect(),
+        ConversionMode::UnblockThenConvert(ct, cbs) => {
+            let mut buf = unblock(&buf, *cbs);
+            apply_conversion(&mut buf, ct);
+            buf
+        }
+        ConversionMode::ConvertThenUnblock(ct, cbs) => {
+            apply_conversion(&mut buf, ct);
+            unblock(&buf, *cbs)
+        }
+        ConversionMode::UnblockOnly(cbs) => unblock(&buf, *cbs),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::blocks::{block, unblock};
+    use crate::progress::ReadStat;
+
+    const NEWLINE: u8 = b'\n';
+    const SPACE: u8 = b' ';
+
+    #[test]
+    fn block_test_no_nl() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, 3u8];
+        let res = block(&buf, 4, false, &mut rs);
+
+        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8],]);
+    }
+
+    #[test]
+    fn block_test_no_nl_short_record() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, 3u8];
+        let res = block(&buf, 8, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],]
+        );
+    }
+
+    #[test]
+    fn block_test_no_nl_trunc() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, 3u8, 4u8];
+        let res = block(&buf, 4, false, &mut rs);
+
+        // Commented section(s) should be truncated and appear for reference only.
+        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8 /*, 4u8*/],]);
+        assert_eq!(rs.records_truncated, 1);
+    }
+
+    #[test]
+    fn block_test_nl_gt_cbs_trunc() {
+        let mut rs = ReadStat::default();
+        let buf = [
+            0u8, 1u8, 2u8, 3u8, 4u8, NEWLINE, 0u8, 1u8, 2u8, 3u8, 4u8, NEWLINE, 5u8, 6u8, 7u8, 8u8,
+        ];
+        let res = block(&buf, 4, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![
+                // Commented section(s) should be truncated and appear for reference only.
+                vec![0u8, 1u8, 2u8, 3u8],
+                // vec![4u8, SPACE, SPACE, SPACE],
+                vec![0u8, 1u8, 2u8, 3u8],
+                // vec![4u8, SPACE, SPACE, SPACE],
+                vec![5u8, 6u8, 7u8, 8u8],
+            ]
+        );
+        assert_eq!(rs.records_truncated, 2);
+    }
+
+    #[test]
+    fn block_test_surrounded_nl() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, 3u8, NEWLINE, 4u8, 5u8, 6u8, 7u8, 8u8];
+        let res = block(&buf, 8, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![
+                vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
+                vec![4u8, 5u8, 6u8, 7u8, 8u8, SPACE, SPACE, SPACE],
+            ]
+        );
+    }
+
+    #[test]
+    fn block_test_multiple_nl_same_cbs_block() {
+        let mut rs = ReadStat::default();
+        let buf = [
+            0u8, 1u8, 2u8, 3u8, NEWLINE, 4u8, NEWLINE, 5u8, 6u8, 7u8, 8u8, 9u8,
+        ];
+        let res = block(&buf, 8, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![
+                vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
+                vec![4u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
+                vec![5u8, 6u8, 7u8, 8u8, 9u8, SPACE, SPACE, SPACE],
+            ]
+        );
+    }
+
+    #[test]
+    fn block_test_multiple_nl_diff_cbs_block() {
+        let mut rs = ReadStat::default();
+        let buf = [
+            0u8, 1u8, 2u8, 3u8, NEWLINE, 4u8, 5u8, 6u8, 7u8, NEWLINE, 8u8, 9u8,
+        ];
+        let res = block(&buf, 8, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![
+                vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
+                vec![4u8, 5u8, 6u8, 7u8, SPACE, SPACE, SPACE, SPACE],
+                vec![8u8, 9u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
+            ]
+        );
+    }
+
+    #[test]
+    fn block_test_end_nl_diff_cbs_block() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, 3u8, NEWLINE];
+        let res = block(&buf, 4, false, &mut rs);
+
+        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8],]);
+    }
+
+    #[test]
+    fn block_test_end_nl_same_cbs_block() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, NEWLINE];
+        let res = block(&buf, 4, false, &mut rs);
+
+        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, SPACE]]);
+    }
+
+    #[test]
+    fn block_test_double_end_nl() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, NEWLINE, NEWLINE];
+        let res = block(&buf, 4, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![vec![0u8, 1u8, 2u8, SPACE], vec![SPACE, SPACE, SPACE, SPACE],]
+        );
+    }
+
+    #[test]
+    fn block_test_start_nl() {
+        let mut rs = ReadStat::default();
+        let buf = [NEWLINE, 0u8, 1u8, 2u8, 3u8];
+        let res = block(&buf, 4, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![vec![SPACE, SPACE, SPACE, SPACE], vec![0u8, 1u8, 2u8, 3u8],]
+        );
+    }
+
+    #[test]
+    fn block_test_double_surrounded_nl_no_trunc() {
+        let mut rs = ReadStat::default();
+        let buf = [0u8, 1u8, 2u8, 3u8, NEWLINE, NEWLINE, 4u8, 5u8, 6u8, 7u8];
+        let res = block(&buf, 8, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![
+                vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
+                vec![SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
+                vec![4u8, 5u8, 6u8, 7u8, SPACE, SPACE, SPACE, SPACE],
+            ]
+        );
+    }
+
+    #[test]
+    fn block_test_double_surrounded_nl_double_trunc() {
+        let mut rs = ReadStat::default();
+        let buf = [
+            0u8, 1u8, 2u8, 3u8, NEWLINE, NEWLINE, 4u8, 5u8, 6u8, 7u8, 8u8,
+        ];
+        let res = block(&buf, 4, false, &mut rs);
+
+        assert_eq!(
+            res,
+            vec![
+                // Commented section(s) should be truncated and appear for reference only.
+                vec![0u8, 1u8, 2u8, 3u8],
+                vec![SPACE, SPACE, SPACE, SPACE],
+                vec![4u8, 5u8, 6u8, 7u8 /*, 8u8*/],
+            ]
+        );
+        assert_eq!(rs.records_truncated, 1);
+    }
+
+    #[test]
+    fn unblock_test_full_cbs() {
+        let buf = [0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8];
+        let res = unblock(&buf, 8);
+
+        assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, NEWLINE],);
+    }
+
+    #[test]
+    fn unblock_test_all_space() {
+        let buf = [SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE];
+        let res = unblock(&buf, 8);
+
+        assert_eq!(res, vec![NEWLINE],);
+    }
+
+    #[test]
+    fn unblock_test_decoy_spaces() {
+        let buf = [0u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, 7u8];
+        let res = unblock(&buf, 8);
+
+        assert_eq!(
+            res,
+            vec![0u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, 7u8, NEWLINE],
+        );
+    }
+
+    #[test]
+    fn unblock_test_strip_single_cbs() {
+        let buf = [0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE];
+        let res = unblock(&buf, 8);
+
+        assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, NEWLINE],);
+    }
+
+    #[test]
+    fn unblock_test_strip_multi_cbs() {
+        let buf = vec![
+            vec![0u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
+            vec![0u8, 1u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
+            vec![0u8, 1u8, 2u8, SPACE, SPACE, SPACE, SPACE, SPACE],
+            vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>();
+
+        let res = unblock(&buf, 8);
+
+        let exp = vec![
+            vec![0u8, NEWLINE],
+            vec![0u8, 1u8, NEWLINE],
+            vec![0u8, 1u8, 2u8, NEWLINE],
+            vec![0u8, 1u8, 2u8, 3u8, NEWLINE],
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>();
+
+        assert_eq!(res, exp);
+    }
+}
diff --git a/src/uu/dd/src/datastructures.rs b/src/uu/dd/src/datastructures.rs
index b4410d210..ffcee4cb1 100644
--- a/src/uu/dd/src/datastructures.rs
+++ b/src/uu/dd/src/datastructures.rs
@@ -4,59 +4,37 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore ctable, outfile
+// spell-checker:ignore ctable, outfile, iseek, oseek
+
+use std::error::Error;
+
+use uucore::error::UError;
 
 use crate::conversion_tables::*;
 
-use std::error::Error;
-use std::time;
-
-pub struct ProgUpdate {
-    pub read_stat: ReadStat,
-    pub write_stat: WriteStat,
-    pub duration: time::Duration,
-}
-
-#[derive(Clone, Copy, Default)]
-pub struct ReadStat {
-    pub reads_complete: u64,
-    pub reads_partial: u64,
-    pub records_truncated: u32,
-}
-impl std::ops::AddAssign for ReadStat {
-    fn add_assign(&mut self, other: Self) {
-        *self = Self {
-            reads_complete: self.reads_complete + other.reads_complete,
-            reads_partial: self.reads_partial + other.reads_partial,
-            records_truncated: self.records_truncated + other.records_truncated,
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct WriteStat {
-    pub writes_complete: u64,
-    pub writes_partial: u64,
-    pub bytes_total: u128,
-}
-impl std::ops::AddAssign for WriteStat {
-    fn add_assign(&mut 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,
-        }
-    }
-}
-
 type Cbs = usize;
 
+/// How to apply conversion, blocking, and/or unblocking.
+///
+/// Certain settings of the `conv` parameter to `dd` require a
+/// combination of conversion, blocking, or unblocking, applied in a
+/// certain order. The variants of this enumeration give the different
+/// ways of combining those three operations.
+#[derive(Debug, PartialEq)]
+pub(crate) enum ConversionMode<'a> {
+    ConvertOnly(&'a ConversionTable),
+    BlockOnly(Cbs, bool),
+    UnblockOnly(Cbs),
+    BlockThenConvert(&'a ConversionTable, Cbs, bool),
+    ConvertThenBlock(&'a ConversionTable, Cbs, bool),
+    UnblockThenConvert(&'a ConversionTable, Cbs),
+    ConvertThenUnblock(&'a ConversionTable, Cbs),
+}
+
 /// Stores all Conv Flags that apply to the input
 #[derive(Debug, Default, PartialEq)]
-pub struct IConvFlags {
-    pub ctable: Option<&'static ConversionTable>,
-    pub block: Option<Cbs>,
-    pub unblock: Option<Cbs>,
+pub(crate) struct IConvFlags {
+    pub mode: Option<ConversionMode<'static>>,
     pub swab: bool,
     pub sync: Option<u8>,
     pub noerror: bool,
@@ -114,46 +92,30 @@ pub struct OFlags {
     pub seek_bytes: bool,
 }
 
-/// The value of the status cl-option.
-/// Controls printing of transfer stats
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum StatusLevel {
-    Progress,
-    Noxfer,
-    None,
-}
-
 /// The value of count=N
 /// Defaults to Reads(N)
 /// if iflag=count_bytes
 /// then becomes Bytes(N)
 #[derive(Debug, PartialEq)]
 pub enum CountType {
-    Reads(usize),
-    Bytes(usize),
+    Reads(u64),
+    Bytes(u64),
 }
 
 #[derive(Debug)]
 pub enum InternalError {
     WrongInputType,
     WrongOutputType,
-    InvalidConvBlockUnblockCase,
 }
 
 impl std::fmt::Display for InternalError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::WrongInputType | Self::WrongOutputType => {
-                write!(f, "Internal dd error: Wrong Input/Output data type")
-            }
-            Self::InvalidConvBlockUnblockCase => {
-                write!(f, "Invalid Conversion, Block, or Unblock data")
-            }
-        }
+        write!(f, "Internal dd error: Wrong Input/Output data type")
     }
 }
 
 impl Error for InternalError {}
+impl UError for InternalError {}
 
 pub mod options {
     pub const INFILE: &str = "if";
@@ -165,6 +127,8 @@ pub mod options {
     pub const COUNT: &str = "count";
     pub const SKIP: &str = "skip";
     pub const SEEK: &str = "seek";
+    pub const ISEEK: &str = "iseek";
+    pub const OSEEK: &str = "oseek";
     pub const STATUS: &str = "status";
     pub const CONV: &str = "conv";
     pub const IFLAG: &str = "iflag";
diff --git a/src/uu/dd/src/dd.rs b/src/uu/dd/src/dd.rs
index 9f1d28714..354e4b261 100644
--- a/src/uu/dd/src/dd.rs
+++ b/src/uu/dd/src/dd.rs
@@ -5,12 +5,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, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
-
-use uucore::InvalidEncodingHandling;
-
-#[cfg(test)]
-mod dd_unit_tests;
+// spell-checker:ignore fname, 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
 
 mod datastructures;
 use datastructures::*;
@@ -21,36 +16,35 @@ use parseargs::Matches;
 mod conversion_tables;
 use conversion_tables::*;
 
-use byte_unit::Byte;
-use clap::{self, crate_version};
-use gcd::Gcd;
-#[cfg(target_os = "linux")]
-use signal_hook::consts::signal;
+mod progress;
+use progress::{gen_prog_updater, ProgUpdate, ReadStat, StatusLevel, WriteStat};
+
+mod blocks;
+use blocks::conv_block_unblock_helper;
+
 use std::cmp;
 use std::convert::TryInto;
 use std::env;
-use std::error::Error;
 use std::fs::{File, OpenOptions};
 use std::io::{self, Read, Seek, Write};
 #[cfg(target_os = "linux")]
 use std::os::unix::fs::OpenOptionsExt;
 use std::path::Path;
 use std::sync::mpsc;
-#[cfg(target_os = "linux")]
-use std::sync::{atomic::AtomicUsize, atomic::Ordering, Arc};
 use std::thread;
 use std::time;
 
+use clap::{crate_version, Arg, ArgMatches, Command};
+use gcd::Gcd;
+use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
+use uucore::{show_error, InvalidEncodingHandling};
+
 const ABOUT: &str = "copy, and optionally convert, a file system resource";
 const BUF_INIT_BYTE: u8 = 0xDD;
-const RTN_SUCCESS: i32 = 0;
-const RTN_FAILURE: i32 = 1;
-const NEWLINE: u8 = b'\n';
-const SPACE: u8 = b' ';
 
 struct Input<R: Read> {
     src: R,
-    non_ascii: bool,
     ibs: usize,
     print_level: Option<StatusLevel>,
     count: Option<CountType>,
@@ -59,18 +53,18 @@ struct Input<R: Read> {
 }
 
 impl Input<io::Stdin> {
-    fn new(matches: &Matches) -> Result<Self, Box<dyn Error>> {
+    fn new(matches: &Matches) -> UResult<Self> {
         let ibs = parseargs::parse_ibs(matches)?;
-        let non_ascii = parseargs::parse_input_non_ascii(matches)?;
         let print_level = parseargs::parse_status_level(matches)?;
         let cflags = parseargs::parse_conv_flag_input(matches)?;
         let iflags = parseargs::parse_iflags(matches)?;
-        let skip = parseargs::parse_skip_amt(&ibs, &iflags, matches)?;
+        let skip = parseargs::parse_seek_skip_amt(&ibs, iflags.skip_bytes, matches, options::SKIP)?;
+        let iseek =
+            parseargs::parse_seek_skip_amt(&ibs, iflags.skip_bytes, matches, options::ISEEK)?;
         let count = parseargs::parse_count(&iflags, matches)?;
 
-        let mut i = Input {
+        let mut i = Self {
             src: io::stdin(),
-            non_ascii,
             ibs,
             print_level,
             count,
@@ -78,10 +72,17 @@ impl Input<io::Stdin> {
             iflags,
         };
 
-        if let Some(amt) = skip {
-            let mut buf = vec![BUF_INIT_BYTE; amt];
-
-            i.force_fill(&mut buf, amt)?;
+        // The --skip and --iseek flags are additive. On a stream, they discard bytes.
+        let amt = skip.unwrap_or(0) + iseek.unwrap_or(0);
+        if amt > 0 {
+            if let Err(e) = i.read_skip(amt) {
+                if let io::ErrorKind::UnexpectedEof = e.kind() {
+                    show_error!("'standard input': cannot skip to specified offset");
+                } else {
+                    return io::Result::Err(e)
+                        .map_err_context(|| "I/O error while skipping".to_string());
+                }
+            }
         }
 
         Ok(i)
@@ -125,13 +126,14 @@ fn make_linux_iflags(iflags: &IFlags) -> Option<libc::c_int> {
 }
 
 impl Input<File> {
-    fn new(matches: &Matches) -> Result<Self, Box<dyn Error>> {
+    fn new(matches: &Matches) -> UResult<Self> {
         let ibs = parseargs::parse_ibs(matches)?;
-        let non_ascii = parseargs::parse_input_non_ascii(matches)?;
         let print_level = parseargs::parse_status_level(matches)?;
         let cflags = parseargs::parse_conv_flag_input(matches)?;
         let iflags = parseargs::parse_iflags(matches)?;
-        let skip = parseargs::parse_skip_amt(&ibs, &iflags, matches)?;
+        let skip = parseargs::parse_seek_skip_amt(&ibs, iflags.skip_bytes, matches, options::SKIP)?;
+        let iseek =
+            parseargs::parse_seek_skip_amt(&ibs, iflags.skip_bytes, matches, options::ISEEK)?;
         let count = parseargs::parse_count(&iflags, matches)?;
 
         if let Some(fname) = matches.value_of(options::INFILE) {
@@ -144,17 +146,19 @@ impl Input<File> {
                     opts.custom_flags(libc_flags);
                 }
 
-                opts.open(fname)?
+                opts.open(fname)
+                    .map_err_context(|| "failed to open input file".to_string())?
             };
 
-            if let Some(amt) = skip {
-                let amt: u64 = amt.try_into()?;
-                src.seek(io::SeekFrom::Start(amt))?;
+            // The --skip and --iseek flags are additive. On a file, they seek.
+            let amt = skip.unwrap_or(0) + iseek.unwrap_or(0);
+            if amt > 0 {
+                src.seek(io::SeekFrom::Start(amt))
+                    .map_err_context(|| "failed to seek in input file".to_string())?;
             }
 
-            let i = Input {
+            let i = Self {
                 src,
-                non_ascii,
                 ibs,
                 print_level,
                 count,
@@ -196,7 +200,7 @@ impl<R: Read> Input<R> {
     /// Fills a given buffer.
     /// Reads in increments of 'self.ibs'.
     /// The start of each ibs-sized read follows the previous one.
-    fn fill_consecutive(&mut self, buf: &mut Vec<u8>) -> Result<ReadStat, Box<dyn Error>> {
+    fn fill_consecutive(&mut self, buf: &mut Vec<u8>) -> std::io::Result<ReadStat> {
         let mut reads_complete = 0;
         let mut reads_partial = 0;
         let mut bytes_total = 0;
@@ -227,7 +231,7 @@ impl<R: Read> Input<R> {
     /// Fills a given buffer.
     /// Reads in increments of 'self.ibs'.
     /// The start of each ibs-sized read is aligned to multiples of ibs; remaining space is filled with the 'pad' byte.
-    fn fill_blocks(&mut self, buf: &mut Vec<u8>, pad: u8) -> Result<ReadStat, Box<dyn Error>> {
+    fn fill_blocks(&mut self, buf: &mut Vec<u8>, pad: u8) -> std::io::Result<ReadStat> {
         let mut reads_complete = 0;
         let mut reads_partial = 0;
         let mut base_idx = 0;
@@ -259,22 +263,23 @@ impl<R: Read> Input<R> {
         })
     }
 
-    /// Force-fills a buffer, ignoring zero-length reads which would otherwise be
-    /// interpreted as EOF.
-    /// Note: This will not return unless the source (eventually) produces
-    /// enough bytes to meet target_len.
-    fn force_fill(&mut self, buf: &mut [u8], target_len: usize) -> Result<usize, Box<dyn Error>> {
-        let mut base_idx = 0;
-        while base_idx < target_len {
-            base_idx += self.read(&mut buf[base_idx..target_len])?;
+    /// Skips amount_to_read bytes from the Input by copying into a sink
+    fn read_skip(&mut self, amount_to_read: u64) -> std::io::Result<()> {
+        let copy_result = io::copy(&mut self.src.by_ref().take(amount_to_read), &mut io::sink());
+        if let Ok(n) = copy_result {
+            if n != amount_to_read {
+                io::Result::Err(io::Error::new(io::ErrorKind::UnexpectedEof, ""))
+            } else {
+                Ok(())
+            }
+        } else {
+            io::Result::Err(copy_result.unwrap_err())
         }
-
-        Ok(base_idx)
     }
 }
 
 trait OutputTrait: Sized + Write {
-    fn new(matches: &Matches) -> Result<Self, Box<dyn Error>>;
+    fn new(matches: &Matches) -> UResult<Self>;
     fn fsync(&mut self) -> io::Result<()>;
     fn fdatasync(&mut self) -> io::Result<()>;
 }
@@ -286,13 +291,25 @@ struct Output<W: Write> {
 }
 
 impl OutputTrait for Output<io::Stdout> {
-    fn new(matches: &Matches) -> Result<Self, Box<dyn Error>> {
+    fn new(matches: &Matches) -> UResult<Self> {
         let obs = parseargs::parse_obs(matches)?;
         let cflags = parseargs::parse_conv_flag_output(matches)?;
+        let oflags = parseargs::parse_oflags(matches)?;
+        let seek = parseargs::parse_seek_skip_amt(&obs, oflags.seek_bytes, matches, options::SEEK)?;
+        let oseek =
+            parseargs::parse_seek_skip_amt(&obs, oflags.seek_bytes, matches, options::OSEEK)?;
 
-        let dst = io::stdout();
+        let mut dst = io::stdout();
 
-        Ok(Output { dst, obs, cflags })
+        // The --seek and --oseek flags are additive.
+        let amt = seek.unwrap_or(0) + oseek.unwrap_or(0);
+        // stdout is not seekable, so we just write null bytes.
+        if amt > 0 {
+            io::copy(&mut io::repeat(0u8).take(amt as u64), &mut dst)
+                .map_err_context(|| String::from("write error"))?;
+        }
+
+        Ok(Self { dst, obs, cflags })
     }
 
     fn fsync(&mut self) -> io::Result<()> {
@@ -308,22 +325,19 @@ impl<W: Write> Output<W>
 where
     Self: OutputTrait,
 {
-    fn write_blocks(&mut self, buf: Vec<u8>) -> io::Result<WriteStat> {
+    fn write_blocks(&mut self, buf: &[u8]) -> io::Result<WriteStat> {
         let mut writes_complete = 0;
         let mut writes_partial = 0;
         let mut bytes_total = 0;
 
         for chunk in buf.chunks(self.obs) {
-            match self.write(chunk)? {
-                wlen if wlen < chunk.len() => {
-                    writes_partial += 1;
-                    bytes_total += wlen;
-                }
-                wlen => {
-                    writes_complete += 1;
-                    bytes_total += wlen;
-                }
+            let wlen = self.write(chunk)?;
+            if wlen < self.obs {
+                writes_partial += 1;
+            } else {
+                writes_complete += 1;
             }
+            bytes_total += wlen;
         }
 
         Ok(WriteStat {
@@ -333,67 +347,111 @@ where
         })
     }
 
-    fn dd_out<R: Read>(mut self, mut i: Input<R>) -> Result<(), Box<dyn Error>> {
-        let mut rstat = ReadStat {
-            reads_complete: 0,
-            reads_partial: 0,
-            records_truncated: 0,
-        };
-        let mut wstat = WriteStat {
-            writes_complete: 0,
-            writes_partial: 0,
-            bytes_total: 0,
-        };
+    /// Print the read/write statistics.
+    fn print_stats<R: Read>(&self, i: &Input<R>, prog_update: &ProgUpdate) {
+        match i.print_level {
+            Some(StatusLevel::None) => {}
+            Some(StatusLevel::Noxfer) => prog_update.print_io_lines(),
+            Some(StatusLevel::Progress) | None => prog_update.print_transfer_stats(),
+        }
+    }
+
+    /// Flush the output to disk, if configured to do so.
+    fn sync(&mut self) -> std::io::Result<()> {
+        if self.cflags.fsync {
+            self.fsync()
+        } else if self.cflags.fdatasync {
+            self.fdatasync()
+        } else {
+            // Intentionally do nothing in this case.
+            Ok(())
+        }
+    }
+
+    /// Copy the given input data to this output, consuming both.
+    ///
+    /// This method contains the main loop for the `dd` program. Bytes
+    /// are read in blocks from `i` and written in blocks to this
+    /// output. Read/write statistics are reported to stderr as
+    /// configured by the `status` command-line argument.
+    ///
+    /// # Errors
+    ///
+    /// If there is a problem reading from the input or writing to
+    /// this output.
+    fn dd_out<R: Read>(mut self, mut i: Input<R>) -> std::io::Result<()> {
+        // The read and write statistics.
+        //
+        // These objects are counters, initialized to zero. After each
+        // iteration of the main loop, each will be incremented by the
+        // number of blocks read and written, respectively.
+        let mut rstat = Default::default();
+        let mut wstat = Default::default();
+
+        // The time at which the main loop starts executing.
+        //
+        // When `status=progress` is given on the command-line, the
+        // `dd` program reports its progress every second or so. Part
+        // of its report includes the throughput in bytes per second,
+        // which requires knowing how long the process has been
+        // running.
         let start = time::Instant::now();
+
+        // A good buffer size for reading.
+        //
+        // This is an educated guess about a good buffer size based on
+        // the input and output block sizes.
         let bsize = calc_bsize(i.ibs, self.obs);
 
-        let prog_tx = {
-            let (tx, rx) = mpsc::channel();
-            thread::spawn(gen_prog_updater(rx, i.print_level));
-            tx
-        };
+        // Start a thread that reports transfer progress.
+        //
+        // When `status=progress` is given on the command-line, the
+        // `dd` program reports its progress every second or so. We
+        // perform this reporting in a new thread so as not to take
+        // any CPU time away from the actual reading and writing of
+        // data. We send a `ProgUpdate` from the transmitter `prog_tx`
+        // to the receives `rx`, and the receiver prints the transfer
+        // information.
+        let (prog_tx, rx) = mpsc::channel();
+        thread::spawn(gen_prog_updater(rx, i.print_level));
 
+        // 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.count, &rstat, &wstat) {
-            // Read/Write
+            // Read a block from the input then write the block to the output.
+            //
+            // As an optimization, make an educated guess about the
+            // best buffer size for reading based on the number of
+            // blocks already read and the number of blocks remaining.
             let loop_bsize = calc_loop_bsize(&i.count, &rstat, &wstat, i.ibs, bsize);
-            match read_helper(&mut i, loop_bsize)? {
-                (
-                    ReadStat {
-                        reads_complete: 0,
-                        reads_partial: 0,
-                        ..
-                    },
-                    _,
-                ) => break,
-                (rstat_update, buf) => {
-                    let wstat_update = self.write_blocks(buf)?;
+            let (rstat_update, buf) = read_helper(&mut i, loop_bsize)?;
+            if rstat_update.is_empty() {
+                break;
+            }
+            let wstat_update = self.write_blocks(&buf)?;
 
-                    rstat += rstat_update;
-                    wstat += wstat_update;
-                }
-            };
-            // Update Prog
-            prog_tx.send(ProgUpdate {
-                read_stat: rstat,
-                write_stat: wstat,
-                duration: start.elapsed(),
-            })?;
+            // Update the read/write stats and inform the progress thread.
+            //
+            // If the receiver is disconnected, `send()` returns an
+            // error. Since it is just reporting progress and is not
+            // crucial to the operation of `dd`, let's just ignore the
+            // error.
+            rstat += rstat_update;
+            wstat += wstat_update;
+            let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed());
+            prog_tx.send(prog_update).unwrap_or(());
         }
 
-        if self.cflags.fsync {
-            self.fsync()?;
-        } else if self.cflags.fdatasync {
-            self.fdatasync()?;
-        }
+        // Flush the output, if configured to do so.
+        self.sync()?;
 
-        match i.print_level {
-            Some(StatusLevel::Noxfer) | Some(StatusLevel::None) => {}
-            _ => print_transfer_stats(&ProgUpdate {
-                read_stat: rstat,
-                write_stat: wstat,
-                duration: start.elapsed(),
-            }),
-        }
+        // Print the final read/write statistics.
+        let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed());
+        self.print_stats(&i, &prog_update);
         Ok(())
     }
 }
@@ -439,12 +497,11 @@ fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
 }
 
 impl OutputTrait for Output<File> {
-    fn new(matches: &Matches) -> Result<Self, Box<dyn Error>> {
+    fn new(matches: &Matches) -> UResult<Self> {
         fn open_dst(path: &Path, cflags: &OConvFlags, oflags: &OFlags) -> Result<File, io::Error> {
             let mut opts = OpenOptions::new();
             opts.write(true)
                 .create(!cflags.nocreat)
-                .truncate(!cflags.notrunc)
                 .create_new(cflags.excl)
                 .append(oflags.append);
 
@@ -458,17 +515,32 @@ impl OutputTrait for Output<File> {
         let obs = parseargs::parse_obs(matches)?;
         let cflags = parseargs::parse_conv_flag_output(matches)?;
         let oflags = parseargs::parse_oflags(matches)?;
-        let seek = parseargs::parse_seek_amt(&obs, &oflags, matches)?;
+        let seek = parseargs::parse_seek_skip_amt(&obs, oflags.seek_bytes, matches, options::SEEK)?;
+        let oseek =
+            parseargs::parse_seek_skip_amt(&obs, oflags.seek_bytes, matches, options::OSEEK)?;
 
         if let Some(fname) = matches.value_of(options::OUTFILE) {
-            let mut dst = open_dst(Path::new(&fname), &cflags, &oflags)?;
+            let mut dst = open_dst(Path::new(&fname), &cflags, &oflags)
+                .map_err_context(|| format!("failed to open {}", fname.quote()))?;
 
-            if let Some(amt) = seek {
-                let amt: u64 = amt.try_into()?;
-                dst.seek(io::SeekFrom::Start(amt))?;
+            // Seek to the index in the output file, truncating if requested.
+            //
+            // 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`.
+
+            // The --seek and --oseek flags are additive.
+            let i = seek.unwrap_or(0) + oseek.unwrap_or(0);
+            if !cflags.notrunc {
+                dst.set_len(i).ok();
             }
+            dst.seek(io::SeekFrom::Start(i))
+                .map_err_context(|| "failed to seek in output file".to_string())?;
 
-            Ok(Output { dst, obs, cflags })
+            Ok(Self { dst, obs, cflags })
         } else {
             // The following error should only occur if someone
             // mistakenly calls Output::<File>::new() without checking
@@ -528,161 +600,8 @@ impl Write for Output<io::Stdout> {
     }
 }
 
-/// Splits the content of buf into cbs-length blocks
-/// Appends padding as specified by conv=block and cbs=N
-/// Expects ascii encoded data
-fn block(buf: Vec<u8>, cbs: usize, rstat: &mut ReadStat) -> Vec<Vec<u8>> {
-    let mut blocks = buf
-        .split(|&e| e == NEWLINE)
-        .map(|split| split.to_vec())
-        .fold(Vec::new(), |mut blocks, mut split| {
-            if split.len() > cbs {
-                rstat.records_truncated += 1;
-            }
-            split.resize(cbs, SPACE);
-            blocks.push(split);
-
-            blocks
-        });
-
-    if let Some(last) = blocks.last() {
-        if last.iter().all(|&e| e == SPACE) {
-            blocks.pop();
-        }
-    }
-
-    blocks
-}
-
-/// Trims padding from each cbs-length partition of buf
-/// as specified by conv=unblock and cbs=N
-/// Expects ascii encoded data
-fn unblock(buf: Vec<u8>, cbs: usize) -> Vec<u8> {
-    buf.chunks(cbs).fold(Vec::new(), |mut acc, block| {
-        if let Some(last_char_idx) = block.iter().rposition(|&e| e != SPACE) {
-            // Include text up to last space.
-            acc.extend(&block[..=last_char_idx]);
-        }
-
-        acc.push(NEWLINE);
-        acc
-    })
-}
-
-/// A helper for teasing out which options must be applied and in which order.
-/// Some user options, such as the presence of conversion tables, will determine whether the input is assumed to be ascii. The parser sets the Input::non_ascii flag accordingly.
-/// Examples:
-///     - If conv=ebcdic or conv=ibm is specified then block, unblock or swab must be performed before the conversion happens since the source will start in ascii.
-///     - If conv=ascii is specified then block, unblock or swab must be performed after the conversion since the source starts in ebcdic.
-///     - If no conversion is specified then the source is assumed to be in ascii.
-/// For more info see `info dd`
-fn conv_block_unblock_helper<R: Read>(
-    mut buf: Vec<u8>,
-    i: &mut Input<R>,
-    rstat: &mut ReadStat,
-) -> Result<Vec<u8>, Box<dyn Error>> {
-    // Local Predicate Fns -------------------------------------------------
-    fn should_block_then_conv<R: Read>(i: &Input<R>) -> bool {
-        !i.non_ascii && i.cflags.block.is_some()
-    }
-    fn should_conv_then_block<R: Read>(i: &Input<R>) -> bool {
-        i.non_ascii && i.cflags.block.is_some()
-    }
-    fn should_unblock_then_conv<R: Read>(i: &Input<R>) -> bool {
-        !i.non_ascii && i.cflags.unblock.is_some()
-    }
-    fn should_conv_then_unblock<R: Read>(i: &Input<R>) -> bool {
-        i.non_ascii && i.cflags.unblock.is_some()
-    }
-    fn conv_only<R: Read>(i: &Input<R>) -> bool {
-        i.cflags.ctable.is_some() && i.cflags.block.is_none() && i.cflags.unblock.is_none()
-    }
-    // Local Helper Fns ----------------------------------------------------
-    fn apply_conversion(buf: &mut [u8], ct: &ConversionTable) {
-        for idx in 0..buf.len() {
-            buf[idx] = ct[buf[idx] as usize];
-        }
-    }
-    // --------------------------------------------------------------------
-    if conv_only(i) {
-        // no block/unblock
-        let ct = i.cflags.ctable.unwrap();
-        apply_conversion(&mut buf, ct);
-
-        Ok(buf)
-    } else if should_block_then_conv(i) {
-        // ascii input so perform the block first
-        let cbs = i.cflags.block.unwrap();
-
-        let mut blocks = block(buf, cbs, rstat);
-
-        if let Some(ct) = i.cflags.ctable {
-            for buf in blocks.iter_mut() {
-                apply_conversion(buf, ct);
-            }
-        }
-
-        let blocks = blocks.into_iter().flatten().collect();
-
-        Ok(blocks)
-    } else if should_conv_then_block(i) {
-        // Non-ascii so perform the conversion first
-        let cbs = i.cflags.block.unwrap();
-
-        if let Some(ct) = i.cflags.ctable {
-            apply_conversion(&mut buf, ct);
-        }
-
-        let blocks = block(buf, cbs, rstat).into_iter().flatten().collect();
-
-        Ok(blocks)
-    } else if should_unblock_then_conv(i) {
-        // ascii input so perform the unblock first
-        let cbs = i.cflags.unblock.unwrap();
-
-        let mut buf = unblock(buf, cbs);
-
-        if let Some(ct) = i.cflags.ctable {
-            apply_conversion(&mut buf, ct);
-        }
-
-        Ok(buf)
-    } else if should_conv_then_unblock(i) {
-        // Non-ascii input so perform the conversion first
-        let cbs = i.cflags.unblock.unwrap();
-
-        if let Some(ct) = i.cflags.ctable {
-            apply_conversion(&mut buf, ct);
-        }
-
-        let buf = unblock(buf, cbs);
-
-        Ok(buf)
-    } else {
-        // The following error should not happen, as it results from
-        // insufficient command line data. This case should be caught
-        // by the parser before making it this far.
-        // Producing this error is an alternative to risking an unwrap call
-        // on 'cbs' if the required data is not provided.
-        Err(Box::new(InternalError::InvalidConvBlockUnblockCase))
-    }
-}
-
 /// Read helper performs read operations common to all dd reads, and dispatches the buffer to relevant helper functions as dictated by the operations requested by the user.
-fn read_helper<R: Read>(
-    i: &mut Input<R>,
-    bsize: usize,
-) -> Result<(ReadStat, Vec<u8>), Box<dyn Error>> {
-    // Local Predicate Fns -----------------------------------------------
-    fn is_conv<R: Read>(i: &Input<R>) -> bool {
-        i.cflags.ctable.is_some()
-    }
-    fn is_block<R: Read>(i: &Input<R>) -> bool {
-        i.cflags.block.is_some()
-    }
-    fn is_unblock<R: Read>(i: &Input<R>) -> bool {
-        i.cflags.unblock.is_some()
-    }
+fn read_helper<R: Read>(i: &mut Input<R>, bsize: usize) -> std::io::Result<(ReadStat, Vec<u8>)> {
     // Local Helper Fns -------------------------------------------------
     fn perform_swab(buf: &mut [u8]) {
         for base in (1..buf.len()).step_by(2) {
@@ -705,114 +624,13 @@ fn read_helper<R: Read>(
     if i.cflags.swab {
         perform_swab(&mut buf);
     }
-    if is_conv(i) || is_block(i) || is_unblock(i) {
-        let buf = conv_block_unblock_helper(buf, i, &mut rstat)?;
-        Ok((rstat, buf))
-    } else {
-        Ok((rstat, buf))
-    }
-}
 
-// Print io lines of a status update:
-// <complete>+<partial> records in
-// <complete>+<partial> records out
-fn print_io_lines(update: &ProgUpdate) {
-    eprintln!(
-        "{}+{} records in",
-        update.read_stat.reads_complete, update.read_stat.reads_partial
-    );
-    if update.read_stat.records_truncated > 0 {
-        eprintln!("{} truncated records", update.read_stat.records_truncated);
-    }
-    eprintln!(
-        "{}+{} records out",
-        update.write_stat.writes_complete, update.write_stat.writes_partial
-    );
-}
-// Print the progress line of a status update:
-// <byte-count> bytes (<base-1000-size>, <base-2-size>) copied, <time> s, <base-2-rate>/s
-fn make_prog_line(update: &ProgUpdate) -> String {
-    let btotal_metric = Byte::from_bytes(update.write_stat.bytes_total)
-        .get_appropriate_unit(false)
-        .format(0);
-    let btotal_bin = Byte::from_bytes(update.write_stat.bytes_total)
-        .get_appropriate_unit(true)
-        .format(0);
-    let safe_millis = cmp::max(1, update.duration.as_millis());
-    let transfer_rate = Byte::from_bytes(1000 * (update.write_stat.bytes_total / safe_millis))
-        .get_appropriate_unit(false)
-        .format(1);
-
-    format!(
-        "{} bytes ({}, {}) copied, {:.1} s, {}/s",
-        update.write_stat.bytes_total,
-        btotal_metric,
-        btotal_bin,
-        update.duration.as_secs_f64(),
-        transfer_rate
-    )
-}
-// Print progress line only. Overwrite the current line.
-fn reprint_prog_line(update: &ProgUpdate) {
-    eprint!("\r{}", make_prog_line(update));
-}
-// Print progress line only. Print as a new line.
-fn print_prog_line(update: &ProgUpdate) {
-    eprintln!("{}", make_prog_line(update));
-}
-// Print both io lines and progress line.
-fn print_transfer_stats(update: &ProgUpdate) {
-    print_io_lines(update);
-    print_prog_line(update);
-}
-
-// Generate a progress updater that tracks progress, receives updates, and responds to progress update requests (signals).
-// Signals:
-// - SIGUSR1: Trigger progress line reprint. Linux (GNU & BSD) only.
-// - TODO: SIGINFO: Trigger progress line reprint. BSD-style Linux only.
-fn gen_prog_updater(rx: mpsc::Receiver<ProgUpdate>, print_level: Option<StatusLevel>) -> impl Fn() {
-    // --------------------------------------------------------------
-    #[cfg(target_os = "linux")]
-    const SIGUSR1_USIZE: usize = signal::SIGUSR1 as usize;
-    // --------------------------------------------------------------
-    #[cfg(target_os = "linux")]
-    fn posixly_correct() -> bool {
-        env::var("POSIXLY_CORRECT").is_ok()
-    }
-    #[cfg(target_os = "linux")]
-    fn register_linux_signal_handler(sigval: Arc<AtomicUsize>) -> Result<(), Box<dyn Error>> {
-        if !posixly_correct() {
-            signal_hook::flag::register_usize(signal::SIGUSR1, sigval, SIGUSR1_USIZE)?;
-        }
-
-        Ok(())
-    }
-    // --------------------------------------------------------------
-    move || {
-        #[cfg(target_os = "linux")]
-        let sigval = Arc::new(AtomicUsize::new(0));
-
-        #[cfg(target_os = "linux")]
-        register_linux_signal_handler(sigval.clone()).unwrap_or_else(|e| {
-            if Some(StatusLevel::None) != print_level {
-                eprintln!(
-                    "Internal dd Warning: Unable to register signal handler \n\t{}",
-                    e
-                );
-            }
-        });
-
-        while let Ok(update) = rx.recv() {
-            // (Re)print status line if progress is requested.
-            if Some(StatusLevel::Progress) == print_level {
-                reprint_prog_line(&update);
-            }
-            // Handle signals
-            #[cfg(target_os = "linux")]
-            if let SIGUSR1_USIZE = sigval.load(Ordering::Relaxed) {
-                print_transfer_stats(&update);
-            };
+    match i.cflags.mode {
+        Some(ref mode) => {
+            let buf = conv_block_unblock_helper(buf, mode, &mut rstat);
+            Ok((rstat, buf))
         }
+        None => Ok((rstat, buf)),
     }
 }
 
@@ -839,15 +657,14 @@ fn calc_loop_bsize(
 ) -> usize {
     match count {
         Some(CountType::Reads(rmax)) => {
-            let rmax: u64 = (*rmax).try_into().unwrap();
             let rsofar = rstat.reads_complete + rstat.reads_partial;
-            let rremain: usize = (rmax - rsofar).try_into().unwrap();
-            cmp::min(ideal_bsize, rremain * ibs)
+            let rremain = rmax - rsofar;
+            cmp::min(ideal_bsize as u64, rremain * ibs as u64) as usize
         }
         Some(CountType::Bytes(bmax)) => {
             let bmax: u128 = (*bmax).try_into().unwrap();
-            let bremain: usize = (bmax - wstat.bytes_total).try_into().unwrap();
-            cmp::min(ideal_bsize, bremain)
+            let bremain: u128 = bmax - wstat.bytes_total;
+            cmp::min(ideal_bsize as u128, bremain as u128) as usize
         }
         None => ideal_bsize,
     }
@@ -858,7 +675,7 @@ fn calc_loop_bsize(
 fn below_count_limit(count: &Option<CountType>, rstat: &ReadStat, wstat: &WriteStat) -> bool {
     match count {
         Some(CountType::Reads(n)) => {
-            let n = (*n).try_into().unwrap();
+            let n = *n;
             rstat.reads_complete + rstat.reads_partial <= n
         }
         Some(CountType::Bytes(n)) => {
@@ -877,28 +694,8 @@ fn append_dashes_if_not_present(mut acc: Vec<String>, mut s: String) -> Vec<Stri
     acc
 }
 
-macro_rules! unpack_or_rtn (
-    ($i:expr, $o:expr) =>
-    {{
-        match ($i, $o)
-        {
-            (Ok(i), Ok(o)) =>
-                (i,o),
-            (Err(e), _) =>
-            {
-                eprintln!("dd Error: {}", e);
-                return RTN_FAILURE;
-            },
-            (_, Err(e)) =>
-            {
-                eprintln!("dd Error: {}", e);
-                return RTN_FAILURE;
-            },
-        }
-    }};
-);
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let dashed_args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any()
@@ -909,129 +706,141 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         //.after_help(TODO: Add note about multiplier strings here.)
         .get_matches_from(dashed_args);
 
-    let result = match (
+    match (
         matches.is_present(options::INFILE),
         matches.is_present(options::OUTFILE),
     ) {
         (true, true) => {
-            let (i, o) =
-                unpack_or_rtn!(Input::<File>::new(&matches), Output::<File>::new(&matches));
-
-            o.dd_out(i)
+            let i = Input::<File>::new(&matches)?;
+            let o = Output::<File>::new(&matches)?;
+            o.dd_out(i).map_err_context(|| "IO error".to_string())
         }
         (false, true) => {
-            let (i, o) = unpack_or_rtn!(
-                Input::<io::Stdin>::new(&matches),
-                Output::<File>::new(&matches)
-            );
-
-            o.dd_out(i)
+            let i = Input::<io::Stdin>::new(&matches)?;
+            let o = Output::<File>::new(&matches)?;
+            o.dd_out(i).map_err_context(|| "IO error".to_string())
         }
         (true, false) => {
-            let (i, o) = unpack_or_rtn!(
-                Input::<File>::new(&matches),
-                Output::<io::Stdout>::new(&matches)
-            );
-
-            o.dd_out(i)
+            let i = Input::<File>::new(&matches)?;
+            let o = Output::<io::Stdout>::new(&matches)?;
+            o.dd_out(i).map_err_context(|| "IO error".to_string())
         }
         (false, false) => {
-            let (i, o) = unpack_or_rtn!(
-                Input::<io::Stdin>::new(&matches),
-                Output::<io::Stdout>::new(&matches)
-            );
-
-            o.dd_out(i)
-        }
-    };
-    match result {
-        Ok(_) => RTN_SUCCESS,
-        Err(e) => {
-            eprintln!("dd exiting with error:\n\t{}", e);
-            RTN_FAILURE
+            let i = Input::<io::Stdin>::new(&matches)?;
+            let o = Output::<io::Stdout>::new(&matches)?;
+            o.dd_out(i).map_err_context(|| "IO error".to_string())
         }
     }
 }
 
-pub fn uu_app() -> clap::App<'static, 'static> {
-    clap::App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .infer_long_args(true)
         .arg(
-            clap::Arg::with_name(options::INFILE)
+            Arg::new(options::INFILE)
                 .long(options::INFILE)
+                .overrides_with(options::INFILE)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("FILE")
                 .help("(alternatively if=FILE) specifies the file used for input. When not specified, stdin is used instead")
         )
         .arg(
-            clap::Arg::with_name(options::OUTFILE)
+            Arg::new(options::OUTFILE)
                 .long(options::OUTFILE)
+                .overrides_with(options::OUTFILE)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("FILE")
                 .help("(alternatively of=FILE) specifies the file used for output. When not specified, stdout is used instead")
         )
         .arg(
-            clap::Arg::with_name(options::IBS)
+            Arg::new(options::IBS)
                 .long(options::IBS)
+                .overrides_with(options::IBS)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("N")
                 .help("(alternatively ibs=N) specifies the size of buffer used for reads (default: 512). Multiplier strings permitted.")
         )
         .arg(
-            clap::Arg::with_name(options::OBS)
+            Arg::new(options::OBS)
                 .long(options::OBS)
+                .overrides_with(options::OBS)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("N")
                 .help("(alternatively obs=N) specifies the size of buffer used for writes (default: 512). Multiplier strings permitted.")
         )
         .arg(
-            clap::Arg::with_name(options::BS)
+            Arg::new(options::BS)
                 .long(options::BS)
+                .overrides_with(options::BS)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("N")
                 .help("(alternatively bs=N) specifies ibs=N and obs=N (default: 512). If ibs or obs are also specified, bs=N takes precedence. Multiplier strings permitted.")
         )
         .arg(
-            clap::Arg::with_name(options::CBS)
+            Arg::new(options::CBS)
                 .long(options::CBS)
+                .overrides_with(options::CBS)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("N")
                 .help("(alternatively cbs=BYTES) specifies the 'conversion block size' in bytes. Applies to the conv=block, and conv=unblock operations. Multiplier strings permitted.")
         )
         .arg(
-            clap::Arg::with_name(options::SKIP)
+            Arg::new(options::SKIP)
                 .long(options::SKIP)
+                .overrides_with(options::SKIP)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("N")
                 .help("(alternatively skip=N) causes N ibs-sized records of input to be skipped before beginning copy/convert operations. See iflag=count_bytes if skipping N bytes is preferred. Multiplier strings permitted.")
         )
         .arg(
-            clap::Arg::with_name(options::SEEK)
+            Arg::new(options::SEEK)
                 .long(options::SEEK)
+                .overrides_with(options::SEEK)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("N")
                 .help("(alternatively seek=N) seeks N obs-sized records into output before beginning copy/convert operations. See oflag=seek_bytes if seeking N bytes is preferred. Multiplier strings permitted.")
         )
         .arg(
-            clap::Arg::with_name(options::COUNT)
+            Arg::new(options::ISEEK)
+                .long(options::ISEEK)
+                .overrides_with(options::ISEEK)
+                .takes_value(true)
+                .require_equals(true)
+                .value_name("N")
+                .help("(alternatively iseek=N) seeks N obs-sized records into input before beginning copy/convert operations. See iflag=seek_bytes if seeking N bytes is preferred. Multiplier strings permitted.")
+        )
+        .arg(
+            Arg::new(options::OSEEK)
+                .long(options::OSEEK)
+                .overrides_with(options::OSEEK)
+                .takes_value(true)
+                .require_equals(true)
+                .value_name("N")
+                .help("(alternatively oseek=N) seeks N obs-sized records into output before beginning copy/convert operations. See oflag=seek_bytes if seeking N bytes is preferred. Multiplier strings permitted.")
+        )
+        .arg(
+            Arg::new(options::COUNT)
                 .long(options::COUNT)
+                .overrides_with(options::COUNT)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("N")
                 .help("(alternatively count=N) stop reading input after N ibs-sized read operations rather than proceeding until EOF. See iflag=count_bytes if stopping after N bytes is preferred. Multiplier strings permitted.")
         )
         .arg(
-            clap::Arg::with_name(options::STATUS)
+            Arg::new(options::STATUS)
                 .long(options::STATUS)
+                .overrides_with(options::STATUS)
                 .takes_value(true)
                 .require_equals(true)
                 .value_name("LEVEL")
@@ -1054,9 +863,13 @@ Printing performance stats is also triggered by the INFO signal (where supported
 ")
         )
         .arg(
-            clap::Arg::with_name(options::CONV)
+            Arg::new(options::CONV)
                 .long(options::CONV)
                 .takes_value(true)
+                .multiple_occurrences(true)
+                .use_value_delimiter(true)
+                .require_value_delimiter(true)
+                .multiple_values(true)
                 .require_equals(true)
                 .value_name("CONV")
                 .help("(alternatively conv=CONV[,CONV]) specifies a comma-separated list of conversion options or (for legacy reasons) file flags. Conversion options and file flags may be intermixed.
@@ -1091,9 +904,13 @@ Conversion Flags:
 ")
         )
         .arg(
-            clap::Arg::with_name(options::IFLAG)
+            Arg::new(options::IFLAG)
                 .long(options::IFLAG)
                 .takes_value(true)
+                .multiple_occurrences(true)
+                .use_value_delimiter(true)
+                .require_value_delimiter(true)
+                .multiple_values(true)
                 .require_equals(true)
                 .value_name("FLAG")
                 .help("(alternatively iflag=FLAG[,FLAG]) a comma separated list of input flags which specify how the input source is treated. FLAG may be any of the input-flags or general-flags specified below.
@@ -1117,9 +934,13 @@ General-Flags
 ")
         )
         .arg(
-            clap::Arg::with_name(options::OFLAG)
+            Arg::new(options::OFLAG)
                 .long(options::OFLAG)
                 .takes_value(true)
+                .multiple_occurrences(true)
+                .use_value_delimiter(true)
+                .require_value_delimiter(true)
+                .multiple_values(true)
                 .require_equals(true)
                 .value_name("FLAG")
                 .help("(alternatively oflag=FLAG[,FLAG]) a comma separated list of output flags which specify how the output source is treated. FLAG may be any of the output-flags or general-flags specified below.
@@ -1142,3 +963,203 @@ General-Flags
 ")
         )
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::datastructures::{IConvFlags, IFlags, OConvFlags};
+    use crate::{calc_bsize, uu_app, Input, Output, OutputTrait};
+
+    use std::cmp;
+    use std::fs;
+    use std::fs::File;
+    use std::io;
+    use std::io::{BufReader, Read};
+
+    struct LazyReader<R: Read> {
+        src: R,
+    }
+
+    impl<R: Read> Read for LazyReader<R> {
+        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+            let reduced = cmp::max(buf.len() / 2, 1);
+            self.src.read(&mut buf[..reduced])
+        }
+    }
+
+    #[test]
+    fn bsize_test_primes() {
+        let (n, m) = (7901, 7919);
+        let res = calc_bsize(n, m);
+        assert!(res % n == 0);
+        assert!(res % m == 0);
+
+        assert_eq!(res, n * m);
+    }
+
+    #[test]
+    fn bsize_test_rel_prime_obs_greater() {
+        let (n, m) = (7 * 5119, 13 * 5119);
+        let res = calc_bsize(n, m);
+        assert!(res % n == 0);
+        assert!(res % m == 0);
+
+        assert_eq!(res, 7 * 13 * 5119);
+    }
+
+    #[test]
+    fn bsize_test_rel_prime_ibs_greater() {
+        let (n, m) = (13 * 5119, 7 * 5119);
+        let res = calc_bsize(n, m);
+        assert!(res % n == 0);
+        assert!(res % m == 0);
+
+        assert_eq!(res, 7 * 13 * 5119);
+    }
+
+    #[test]
+    fn bsize_test_3fac_rel_prime() {
+        let (n, m) = (11 * 13 * 5119, 7 * 11 * 5119);
+        let res = calc_bsize(n, m);
+        assert!(res % n == 0);
+        assert!(res % m == 0);
+
+        assert_eq!(res, 7 * 11 * 13 * 5119);
+    }
+
+    #[test]
+    fn bsize_test_ibs_greater() {
+        let (n, m) = (512 * 1024, 256 * 1024);
+        let res = calc_bsize(n, m);
+        assert!(res % n == 0);
+        assert!(res % m == 0);
+
+        assert_eq!(res, n);
+    }
+
+    #[test]
+    fn bsize_test_obs_greater() {
+        let (n, m) = (256 * 1024, 512 * 1024);
+        let res = calc_bsize(n, m);
+        assert!(res % n == 0);
+        assert!(res % m == 0);
+
+        assert_eq!(res, m);
+    }
+
+    #[test]
+    fn bsize_test_bs_eq() {
+        let (n, m) = (1024, 1024);
+        let res = calc_bsize(n, m);
+        assert!(res % n == 0);
+        assert!(res % m == 0);
+
+        assert_eq!(res, m);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_nocreat_causes_failure_when_ofile_doesnt_exist() {
+        let args = vec![
+            String::from("dd"),
+            String::from("--conv=nocreat"),
+            String::from("--of=not-a-real.file"),
+        ];
+
+        let matches = uu_app().try_get_matches_from(args).unwrap();
+        let _ = Output::<File>::new(&matches).unwrap();
+    }
+
+    #[test]
+    fn test_deadbeef_16_delayed() {
+        let input = Input {
+            src: LazyReader {
+                src: File::open("./test-resources/deadbeef-16.test").unwrap(),
+            },
+            ibs: 16,
+            print_level: None,
+            count: None,
+            cflags: IConvFlags {
+                sync: Some(0),
+                ..IConvFlags::default()
+            },
+            iflags: IFlags::default(),
+        };
+
+        let output = Output {
+            dst: File::create("./test-resources/FAILED-deadbeef-16-delayed.test").unwrap(),
+            obs: 32,
+            cflags: OConvFlags::default(),
+        };
+
+        output.dd_out(input).unwrap();
+
+        let tmp_fname = "./test-resources/FAILED-deadbeef-16-delayed.test";
+        let spec = File::open("./test-resources/deadbeef-16.spec").unwrap();
+
+        let res = File::open(tmp_fname).unwrap();
+        // Check test file isn't empty (unless spec file is too)
+        assert_eq!(
+            res.metadata().unwrap().len(),
+            spec.metadata().unwrap().len()
+        );
+
+        let spec = BufReader::new(spec);
+        let res = BufReader::new(res);
+
+        // Check all bytes match
+        for (b_res, b_spec) in res.bytes().zip(spec.bytes()) {
+            assert_eq!(b_res.unwrap(), b_spec.unwrap());
+        }
+
+        fs::remove_file(tmp_fname).unwrap();
+    }
+
+    #[test]
+    fn test_random_73k_test_lazy_fullblock() {
+        let input = Input {
+            src: LazyReader {
+                src: File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test")
+                    .unwrap(),
+            },
+            ibs: 521,
+            print_level: None,
+            count: None,
+            cflags: IConvFlags::default(),
+            iflags: IFlags {
+                fullblock: true,
+                ..IFlags::default()
+            },
+        };
+
+        let output = Output {
+            dst: File::create("./test-resources/FAILED-random_73k_test_lazy_fullblock.test")
+                .unwrap(),
+            obs: 1031,
+            cflags: OConvFlags::default(),
+        };
+
+        output.dd_out(input).unwrap();
+
+        let tmp_fname = "./test-resources/FAILED-random_73k_test_lazy_fullblock.test";
+        let spec =
+            File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap();
+
+        let res = File::open(tmp_fname).unwrap();
+        // Check test file isn't empty (unless spec file is too)
+        assert_eq!(
+            res.metadata().unwrap().len(),
+            spec.metadata().unwrap().len()
+        );
+
+        let spec = BufReader::new(spec);
+        let res = BufReader::new(res);
+
+        // Check all bytes match
+        for (b_res, b_spec) in res.bytes().zip(spec.bytes()) {
+            assert_eq!(b_res.unwrap(), b_spec.unwrap());
+        }
+
+        fs::remove_file(tmp_fname).unwrap();
+    }
+}
diff --git a/src/uu/dd/src/dd_unit_tests/block_unblock_tests.rs b/src/uu/dd/src/dd_unit_tests/block_unblock_tests.rs
deleted file mode 100644
index e2cfa77d0..000000000
--- a/src/uu/dd/src/dd_unit_tests/block_unblock_tests.rs
+++ /dev/null
@@ -1,351 +0,0 @@
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
-
-use super::*;
-
-#[cfg(unix)]
-macro_rules! make_block_test (
-    ( $test_id:ident, $test_name:expr, $src:expr, $block:expr, $spec:expr ) =>
-    {
-        make_spec_test!($test_id,
-                        $test_name,
-                        Input {
-                            src: $src,
-                            non_ascii: false,
-                            ibs: 512,
-                            print_level: None,
-                            count: None,
-                            cflags: IConvFlags {
-                                block: $block,
-                                ..IConvFlags::default()
-                            },
-                            iflags: IFlags::default(),
-                        },
-                        Output {
-                            dst: File::create(format!("./test-resources/FAILED-{}.test", $test_name)).unwrap(),
-                            obs: 512,
-                            cflags: OConvFlags::default(),
-                        },
-                        $spec,
-                        format!("./test-resources/FAILED-{}.test", $test_name)
-        );
-    };
-);
-
-#[cfg(unix)]
-macro_rules! make_unblock_test (
-    ( $test_id:ident, $test_name:expr, $src:expr, $unblock:expr, $spec:expr ) =>
-    {
-        make_spec_test!($test_id,
-                        $test_name,
-                        Input {
-                            src: $src,
-                            non_ascii: false,
-                            ibs: 512,
-                            print_level: None,
-                            count: None,
-                            cflags: IConvFlags {
-                                unblock: $unblock,
-                                ..IConvFlags::default()
-                            },
-                            iflags: IFlags::default(),
-                        },
-                        Output {
-                            dst: File::create(format!("./test-resources/FAILED-{}.test", $test_name)).unwrap(),
-                            obs: 512,
-                            cflags: OConvFlags::default(),
-                        },
-                        $spec,
-                        format!("./test-resources/FAILED-{}.test", $test_name)
-        );
-    };
-);
-
-#[test]
-fn block_test_no_nl() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, 3u8];
-    let res = block(buf, 4, &mut rs);
-
-    assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8],]);
-}
-
-#[test]
-fn block_test_no_nl_short_record() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, 3u8];
-    let res = block(buf, 8, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],]
-    );
-}
-
-#[test]
-fn block_test_no_nl_trunc() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, 3u8, 4u8];
-    let res = block(buf, 4, &mut rs);
-
-    // Commented section(s) should be truncated and appear for reference only.
-    assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8 /*, 4u8*/],]);
-    assert_eq!(rs.records_truncated, 1);
-}
-
-#[test]
-fn block_test_nl_gt_cbs_trunc() {
-    let mut rs = ReadStat::default();
-    let buf = vec![
-        0u8, 1u8, 2u8, 3u8, 4u8, NEWLINE, 0u8, 1u8, 2u8, 3u8, 4u8, NEWLINE, 5u8, 6u8, 7u8, 8u8,
-    ];
-    let res = block(buf, 4, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![
-            // Commented section(s) should be truncated and appear for reference only.
-            vec![0u8, 1u8, 2u8, 3u8],
-            // vec![4u8, SPACE, SPACE, SPACE],
-            vec![0u8, 1u8, 2u8, 3u8],
-            // vec![4u8, SPACE, SPACE, SPACE],
-            vec![5u8, 6u8, 7u8, 8u8],
-        ]
-    );
-    assert_eq!(rs.records_truncated, 2);
-}
-
-#[test]
-fn block_test_surrounded_nl() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, 3u8, NEWLINE, 4u8, 5u8, 6u8, 7u8, 8u8];
-    let res = block(buf, 8, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![
-            vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
-            vec![4u8, 5u8, 6u8, 7u8, 8u8, SPACE, SPACE, SPACE],
-        ]
-    );
-}
-
-#[test]
-fn block_test_multiple_nl_same_cbs_block() {
-    let mut rs = ReadStat::default();
-    let buf = vec![
-        0u8, 1u8, 2u8, 3u8, NEWLINE, 4u8, NEWLINE, 5u8, 6u8, 7u8, 8u8, 9u8,
-    ];
-    let res = block(buf, 8, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![
-            vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
-            vec![4u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
-            vec![5u8, 6u8, 7u8, 8u8, 9u8, SPACE, SPACE, SPACE],
-        ]
-    );
-}
-
-#[test]
-fn block_test_multiple_nl_diff_cbs_block() {
-    let mut rs = ReadStat::default();
-    let buf = vec![
-        0u8, 1u8, 2u8, 3u8, NEWLINE, 4u8, 5u8, 6u8, 7u8, NEWLINE, 8u8, 9u8,
-    ];
-    let res = block(buf, 8, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![
-            vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
-            vec![4u8, 5u8, 6u8, 7u8, SPACE, SPACE, SPACE, SPACE],
-            vec![8u8, 9u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
-        ]
-    );
-}
-
-#[test]
-fn block_test_end_nl_diff_cbs_block() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, 3u8, NEWLINE];
-    let res = block(buf, 4, &mut rs);
-
-    assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8],]);
-}
-
-#[test]
-fn block_test_end_nl_same_cbs_block() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, NEWLINE];
-    let res = block(buf, 4, &mut rs);
-
-    assert_eq!(res, vec![vec![0u8, 1u8, 2u8, SPACE]]);
-}
-
-#[test]
-fn block_test_double_end_nl() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, NEWLINE, NEWLINE];
-    let res = block(buf, 4, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![vec![0u8, 1u8, 2u8, SPACE], vec![SPACE, SPACE, SPACE, SPACE],]
-    );
-}
-
-#[test]
-fn block_test_start_nl() {
-    let mut rs = ReadStat::default();
-    let buf = vec![NEWLINE, 0u8, 1u8, 2u8, 3u8];
-    let res = block(buf, 4, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![vec![SPACE, SPACE, SPACE, SPACE], vec![0u8, 1u8, 2u8, 3u8],]
-    );
-}
-
-#[test]
-fn block_test_double_surrounded_nl_no_trunc() {
-    let mut rs = ReadStat::default();
-    let buf = vec![0u8, 1u8, 2u8, 3u8, NEWLINE, NEWLINE, 4u8, 5u8, 6u8, 7u8];
-    let res = block(buf, 8, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![
-            vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
-            vec![SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
-            vec![4u8, 5u8, 6u8, 7u8, SPACE, SPACE, SPACE, SPACE],
-        ]
-    );
-}
-
-#[test]
-fn block_test_double_surrounded_nl_double_trunc() {
-    let mut rs = ReadStat::default();
-    let buf = vec![
-        0u8, 1u8, 2u8, 3u8, NEWLINE, NEWLINE, 4u8, 5u8, 6u8, 7u8, 8u8,
-    ];
-    let res = block(buf, 4, &mut rs);
-
-    assert_eq!(
-        res,
-        vec![
-            // Commented section(s) should be truncated and appear for reference only.
-            vec![0u8, 1u8, 2u8, 3u8],
-            vec![SPACE, SPACE, SPACE, SPACE],
-            vec![4u8, 5u8, 6u8, 7u8 /*, 8u8*/],
-        ]
-    );
-    assert_eq!(rs.records_truncated, 1);
-}
-
-#[cfg(unix)]
-make_block_test!(
-    block_cbs16,
-    "block-cbs-16",
-    File::open("./test-resources/dd-block-cbs16.test").unwrap(),
-    Some(16),
-    File::open("./test-resources/dd-block-cbs16.spec").unwrap()
-);
-
-#[cfg(unix)]
-make_block_test!(
-    block_cbs16_as_cbs8,
-    "block-cbs-16-as-cbs8",
-    File::open("./test-resources/dd-block-cbs16.test").unwrap(),
-    Some(8),
-    File::open("./test-resources/dd-block-cbs8.spec").unwrap()
-);
-
-#[cfg(unix)]
-make_block_test!(
-    block_consecutive_nl,
-    "block-consecutive-nl",
-    File::open("./test-resources/dd-block-consecutive-nl.test").unwrap(),
-    Some(16),
-    File::open("./test-resources/dd-block-consecutive-nl-cbs16.spec").unwrap()
-);
-
-#[test]
-fn unblock_test_full_cbs() {
-    let buf = vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8];
-    let res = unblock(buf, 8);
-
-    assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, NEWLINE],);
-}
-
-#[test]
-fn unblock_test_all_space() {
-    let buf = vec![SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE];
-    let res = unblock(buf, 8);
-
-    assert_eq!(res, vec![NEWLINE],);
-}
-
-#[test]
-fn unblock_test_decoy_spaces() {
-    let buf = vec![0u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, 7u8];
-    let res = unblock(buf, 8);
-
-    assert_eq!(
-        res,
-        vec![0u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, 7u8, NEWLINE],
-    );
-}
-
-#[test]
-fn unblock_test_strip_single_cbs() {
-    let buf = vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE];
-    let res = unblock(buf, 8);
-
-    assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, NEWLINE],);
-}
-
-#[test]
-fn unblock_test_strip_multi_cbs() {
-    let buf = vec![
-        vec![0u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
-        vec![0u8, 1u8, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE],
-        vec![0u8, 1u8, 2u8, SPACE, SPACE, SPACE, SPACE, SPACE],
-        vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],
-    ]
-    .into_iter()
-    .flatten()
-    .collect::<Vec<_>>();
-
-    let res = unblock(buf, 8);
-
-    let exp = vec![
-        vec![0u8, NEWLINE],
-        vec![0u8, 1u8, NEWLINE],
-        vec![0u8, 1u8, 2u8, NEWLINE],
-        vec![0u8, 1u8, 2u8, 3u8, NEWLINE],
-    ]
-    .into_iter()
-    .flatten()
-    .collect::<Vec<_>>();
-
-    assert_eq!(res, exp);
-}
-
-#[cfg(unix)]
-make_unblock_test!(
-    unblock_multi_16,
-    "unblock-multi-16",
-    File::open("./test-resources/dd-unblock-cbs16.test").unwrap(),
-    Some(16),
-    File::open("./test-resources/dd-unblock-cbs16.spec").unwrap()
-);
-
-#[cfg(unix)]
-make_unblock_test!(
-    unblock_multi_16_as_8,
-    "unblock-multi-16-as-8",
-    File::open("./test-resources/dd-unblock-cbs16.test").unwrap(),
-    Some(8),
-    File::open("./test-resources/dd-unblock-cbs8.spec").unwrap()
-);
diff --git a/src/uu/dd/src/dd_unit_tests/conv_sync_tests.rs b/src/uu/dd/src/dd_unit_tests/conv_sync_tests.rs
deleted file mode 100644
index 904a97cf5..000000000
--- a/src/uu/dd/src/dd_unit_tests/conv_sync_tests.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
-
-use super::*;
-
-macro_rules! make_sync_test (
-    ( $test_id:ident, $test_name:expr, $src:expr, $sync:expr, $ibs:expr, $obs:expr, $spec:expr ) =>
-    {
-        make_spec_test!($test_id,
-                        $test_name,
-                        Input {
-                            src: $src,
-                            non_ascii: false,
-                            ibs: $ibs,
-                            print_level: None,
-                            count: None,
-                            cflags: IConvFlags {
-                                sync: $sync,
-                                ..IConvFlags::default()
-                            },
-                            iflags: IFlags::default(),
-                        },
-                        Output {
-                            dst: File::create(format!("./test-resources/FAILED-{}.test", $test_name)).unwrap(),
-                            obs: $obs,
-                            cflags: OConvFlags::default(),
-                        },
-                        $spec,
-                        format!("./test-resources/FAILED-{}.test", $test_name)
-        );
-    };
-);
-
-// Zeros
-make_sync_test!(
-    zeros_4k_conv_sync_obs_gt_ibs,
-    "zeros_4k_conv_sync_obs_gt_ibs",
-    File::open("./test-resources/zeros-620f0b67a91f7f74151bc5be745b7110.test").unwrap(),
-    Some(0u8),
-    521,
-    1031,
-    File::open("./test-resources/gnudd-conv-sync-ibs-521-obs-1031-zeros.spec").unwrap()
-);
-
-make_sync_test!(
-    zeros_4k_conv_sync_ibs_gt_obs,
-    "zeros_4k_conv_sync_ibs_gt_obs",
-    File::open("./test-resources/zeros-620f0b67a91f7f74151bc5be745b7110.test").unwrap(),
-    Some(0u8),
-    1031,
-    521,
-    File::open("./test-resources/gnudd-conv-sync-ibs-1031-obs-521-zeros.spec").unwrap()
-);
-
-// Deadbeef
-make_sync_test!(
-    deadbeef_32k_conv_sync_obs_gt_ibs,
-    "deadbeef_32k_conv_sync_obs_gt_ibs",
-    File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap(),
-    Some(0u8),
-    521,
-    1031,
-    File::open("./test-resources/gnudd-conv-sync-ibs-521-obs-1031-deadbeef.spec").unwrap()
-);
-
-make_sync_test!(
-    deadbeef_32k_conv_sync_ibs_gt_obs,
-    "deadbeef_32k_conv_sync_ibs_gt_obs",
-    File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap(),
-    Some(0u8),
-    1031,
-    521,
-    File::open("./test-resources/gnudd-conv-sync-ibs-1031-obs-521-deadbeef.spec").unwrap()
-);
-
-// Random
-make_sync_test!(
-    random_73k_test_bs_prime_obs_gt_ibs_sync,
-    "random-73k-test-bs-prime-obs-gt-ibs-sync",
-    File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap(),
-    Some(0u8),
-    521,
-    1031,
-    File::open("./test-resources/gnudd-conv-sync-ibs-521-obs-1031-random.spec").unwrap()
-);
-
-make_sync_test!(
-    random_73k_test_bs_prime_ibs_gt_obs_sync,
-    "random-73k-test-bs-prime-ibs-gt-obs-sync",
-    File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap(),
-    Some(0u8),
-    1031,
-    521,
-    File::open("./test-resources/gnudd-conv-sync-ibs-1031-obs-521-random.spec").unwrap()
-);
-
-make_sync_test!(
-    deadbeef_16_delayed,
-    "deadbeef-16-delayed",
-    LazyReader {
-        src: File::open("./test-resources/deadbeef-16.test").unwrap()
-    },
-    Some(0u8),
-    16,
-    32,
-    File::open("./test-resources/deadbeef-16.spec").unwrap()
-);
diff --git a/src/uu/dd/src/dd_unit_tests/conversion_tests.rs b/src/uu/dd/src/dd_unit_tests/conversion_tests.rs
deleted file mode 100644
index 9255a1a89..000000000
--- a/src/uu/dd/src/dd_unit_tests/conversion_tests.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
-
-use super::*;
-
-macro_rules! make_conv_test (
-    ( $test_id:ident, $test_name:expr, $src:expr, $ctable:expr, $spec:expr ) =>
-    {
-        make_spec_test!($test_id,
-                        $test_name,
-                        Input {
-                            src: $src,
-                            non_ascii: false,
-                            ibs: 512,
-                            print_level: None,
-                            count: None,
-                            cflags: icf!($ctable),
-                            iflags: IFlags::default(),
-                        },
-                        Output {
-                            dst: File::create(format!("./test-resources/FAILED-{}.test", $test_name)).unwrap(),
-                            obs: 512,
-                            cflags: OConvFlags::default(),
-                        },
-                        $spec,
-                        format!("./test-resources/FAILED-{}.test", $test_name)
-        );
-    };
-);
-
-macro_rules! make_icf_test (
-    ( $test_id:ident, $test_name:expr, $src:expr, $icf:expr, $spec:expr ) =>
-    {
-        make_spec_test!($test_id,
-                        $test_name,
-                        Input {
-                            src: $src,
-                            non_ascii: false,
-                            ibs: 512,
-                            print_level: None,
-                            count: None,
-                            cflags: $icf,
-                            iflags: IFlags::default(),
-                        },
-                        Output {
-                            dst: File::create(format!("./test-resources/FAILED-{}.test", $test_name)).unwrap(),
-                            obs: 512,
-                            cflags: OConvFlags::default(),
-                        },
-                        $spec,
-                        format!("./test-resources/FAILED-{}.test", $test_name)
-        );
-    };
-);
-
-make_conv_test!(
-    atoe_conv_spec_test,
-    "atoe-conv-spec-test",
-    File::open("./test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test").unwrap(),
-    Some(&ASCII_TO_EBCDIC),
-    File::open("./test-resources/gnudd-conv-atoe-seq-byte-values.spec").unwrap()
-);
-
-make_conv_test!(
-    etoa_conv_spec_test,
-    "etoa-conv-spec-test",
-    File::open("./test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test").unwrap(),
-    Some(&EBCDIC_TO_ASCII),
-    File::open("./test-resources/gnudd-conv-etoa-seq-byte-values.spec").unwrap()
-);
-
-make_conv_test!(
-    atoibm_conv_spec_test,
-    "atoibm-conv-spec-test",
-    File::open("./test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test").unwrap(),
-    Some(&ASCII_TO_IBM),
-    File::open("./test-resources/gnudd-conv-atoibm-seq-byte-values.spec").unwrap()
-);
-
-make_conv_test!(
-    lcase_ascii_to_ucase_ascii,
-    "lcase_ascii_to_ucase_ascii",
-    File::open("./test-resources/lcase-ascii.test").unwrap(),
-    Some(&ASCII_LCASE_TO_UCASE),
-    File::open("./test-resources/ucase-ascii.test").unwrap()
-);
-
-make_conv_test!(
-    ucase_ascii_to_lcase_ascii,
-    "ucase_ascii_to_lcase_ascii",
-    File::open("./test-resources/ucase-ascii.test").unwrap(),
-    Some(&ASCII_UCASE_TO_LCASE),
-    File::open("./test-resources/lcase-ascii.test").unwrap()
-);
-
-make_conv_test!(
-    // conv=ebcdic,ucase
-    atoe_and_ucase_conv_spec_test,
-    "atoe-and-ucase-conv-spec-test",
-    File::open("./test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test").unwrap(),
-    Some(&ASCII_TO_EBCDIC_LCASE_TO_UCASE),
-    File::open("./test-resources/ucase-ebcdic.test").unwrap()
-);
-
-make_conv_test!(
-    // conv=ebcdic,lcase
-    atoe_and_lcase_conv_spec_test,
-    "atoe-and-lcase-conv-spec-test",
-    File::open("./test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test").unwrap(),
-    Some(&ASCII_TO_EBCDIC_UCASE_TO_LCASE),
-    File::open("./test-resources/lcase-ebcdic.test").unwrap()
-);
-
-make_conv_test!(
-    // conv=ibm,ucase
-    atoibm_and_ucase_conv_spec_test,
-    "atoibm-and-ucase-conv-spec-test",
-    File::open("./test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test").unwrap(),
-    Some(&ASCII_TO_IBM_UCASE_TO_LCASE),
-    File::open("./test-resources/lcase-ibm.test").unwrap()
-);
-
-make_conv_test!(
-    // conv=ibm,lcase
-    atoibm_and_lcase_conv_spec_test,
-    "atoibm-and-lcase-conv-spec-test",
-    File::open("./test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test").unwrap(),
-    Some(&ASCII_TO_IBM_LCASE_TO_UCASE),
-    File::open("./test-resources/ucase-ibm.test").unwrap()
-);
-
-#[test]
-fn all_valid_ascii_ebcdic_ascii_roundtrip_conv_test() {
-    // ASCII->EBCDIC
-    let test_name = "all-valid-ascii-to-ebcdic";
-    let tmp_fname_ae = format!("./test-resources/FAILED-{}.test", test_name);
-
-    let i = Input {
-        src: File::open(
-            "./test-resources/all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test",
-        )
-        .unwrap(),
-        non_ascii: false,
-        ibs: 128,
-        print_level: None,
-        count: None,
-        cflags: icf!(Some(&ASCII_TO_EBCDIC)),
-        iflags: IFlags::default(),
-    };
-
-    let o = Output {
-        dst: File::create(&tmp_fname_ae).unwrap(),
-        obs: 1024,
-        cflags: OConvFlags::default(),
-    };
-
-    o.dd_out(i).unwrap();
-
-    // EBCDIC->ASCII
-    let test_name = "all-valid-ebcdic-to-ascii";
-    let tmp_fname_ea = format!("./test-resources/FAILED-{}.test", test_name);
-
-    let i = Input {
-        src: File::open(&tmp_fname_ae).unwrap(),
-        non_ascii: false,
-        ibs: 256,
-        print_level: None,
-        count: None,
-        cflags: icf!(Some(&EBCDIC_TO_ASCII)),
-        iflags: IFlags::default(),
-    };
-
-    let o = Output {
-        dst: File::create(&tmp_fname_ea).unwrap(),
-        obs: 1024,
-        cflags: OConvFlags::default(),
-    };
-
-    o.dd_out(i).unwrap();
-
-    // Final Comparison
-    let res = File::open(&tmp_fname_ea).unwrap();
-    let spec =
-        File::open("./test-resources/all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test")
-            .unwrap();
-
-    assert_eq!(
-        res.metadata().unwrap().len(),
-        spec.metadata().unwrap().len()
-    );
-
-    let res = BufReader::new(res);
-    let spec = BufReader::new(spec);
-
-    let res = BufReader::new(res);
-
-    // Check all bytes match
-    for (b_res, b_spec) in res.bytes().zip(spec.bytes()) {
-        assert_eq!(b_res.unwrap(), b_spec.unwrap());
-    }
-
-    fs::remove_file(&tmp_fname_ae).unwrap();
-    fs::remove_file(&tmp_fname_ea).unwrap();
-}
-
-make_icf_test!(
-    swab_256_test,
-    "swab-256",
-    File::open("./test-resources/seq-byte-values.test").unwrap(),
-    IConvFlags {
-        ctable: None,
-        block: None,
-        unblock: None,
-        swab: true,
-        sync: None,
-        noerror: false,
-    },
-    File::open("./test-resources/seq-byte-values-swapped.test").unwrap()
-);
-
-make_icf_test!(
-    swab_257_test,
-    "swab-257",
-    File::open("./test-resources/seq-byte-values-odd.test").unwrap(),
-    IConvFlags {
-        ctable: None,
-        block: None,
-        unblock: None,
-        swab: true,
-        sync: None,
-        noerror: false,
-    },
-    File::open("./test-resources/seq-byte-values-odd.spec").unwrap()
-);
diff --git a/src/uu/dd/src/dd_unit_tests/mod.rs b/src/uu/dd/src/dd_unit_tests/mod.rs
deleted file mode 100644
index 9641c9bba..000000000
--- a/src/uu/dd/src/dd_unit_tests/mod.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
-
-use super::*;
-
-mod block_unblock_tests;
-mod conv_sync_tests;
-mod conversion_tests;
-mod sanity_tests;
-
-use std::fs;
-use std::io::prelude::*;
-use std::io::BufReader;
-
-struct LazyReader<R: Read> {
-    src: R,
-}
-
-impl<R: Read> Read for LazyReader<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let reduced = cmp::max(buf.len() / 2, 1);
-        self.src.read(&mut buf[..reduced])
-    }
-}
-
-#[macro_export]
-macro_rules! icf (
-    ( $ctable:expr ) =>
-    {
-        IConvFlags {
-            ctable: $ctable,
-            ..IConvFlags::default()
-        }
-    };
-);
-
-#[macro_export]
-macro_rules! make_spec_test (
-    ( $test_id:ident, $test_name:expr, $src:expr ) =>
-    {
-        // When spec not given, output should match input
-        make_spec_test!($test_id, $test_name, $src, $src);
-    };
-    ( $test_id:ident, $test_name:expr, $src:expr, $spec:expr ) =>
-    {
-        make_spec_test!($test_id,
-                        $test_name,
-                        Input {
-                            src: $src,
-                            non_ascii: false,
-                            ibs: 512,
-                            print_level: None,
-                            count: None,
-                            cflags: IConvFlags::default(),
-                            iflags: IFlags::default(),
-                        },
-                        Output {
-                            dst: File::create(format!("./test-resources/FAILED-{}.test", $test_name)).unwrap(),
-                            obs: 512,
-                            cflags: OConvFlags::default(),
-                        },
-                        $spec,
-                        format!("./test-resources/FAILED-{}.test", $test_name)
-        );
-    };
-    ( $test_id:ident, $test_name:expr, $i:expr, $o:expr, $spec:expr, $tmp_fname:expr ) =>
-    {
-        #[test]
-        fn $test_id()
-        {
-            $o.dd_out($i).unwrap();
-
-            let res = File::open($tmp_fname).unwrap();
-            // Check test file isn't empty (unless spec file is too)
-            assert_eq!(res.metadata().unwrap().len(), $spec.metadata().unwrap().len());
-
-            let spec = BufReader::new($spec);
-            let res = BufReader::new(res);
-
-            // Check all bytes match
-            for (b_res, b_spec) in res.bytes().zip(spec.bytes())
-            {
-                assert_eq!(b_res.unwrap(),
-                           b_spec.unwrap());
-            }
-
-            fs::remove_file($tmp_fname).unwrap();
-        }
-    };
-);
diff --git a/src/uu/dd/src/dd_unit_tests/sanity_tests.rs b/src/uu/dd/src/dd_unit_tests/sanity_tests.rs
deleted file mode 100644
index edf25fe5d..000000000
--- a/src/uu/dd/src/dd_unit_tests/sanity_tests.rs
+++ /dev/null
@@ -1,316 +0,0 @@
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
-
-use super::*;
-
-const DST_PLACEHOLDER: Vec<u8> = Vec::new();
-
-macro_rules! make_io_test (
-    ( $test_id:ident, $test_name:expr, $i:expr, $o:expr, $spec:expr ) =>
-    {
-        make_spec_test!($test_id,
-                        $test_name,
-                        $i,
-                        Output {
-                            dst: File::create(format!("./test-resources/FAILED-{}.test", $test_name)).unwrap(),
-                            obs: $o.obs,
-                            cflags: $o.cflags,
-                        },
-                        $spec,
-                        format!("./test-resources/FAILED-{}.test", $test_name)
-        );
-    };
-);
-
-make_spec_test!(
-    zeros_4k_test,
-    "zeros-4k",
-    File::open("./test-resources/zeros-620f0b67a91f7f74151bc5be745b7110.test").unwrap()
-);
-
-make_spec_test!(
-    ones_4k_test,
-    "ones-4k",
-    File::open("./test-resources/ones-6ae59e64850377ee5470c854761551ea.test").unwrap()
-);
-
-make_spec_test!(
-    deadbeef_32k_test,
-    "deadbeef-32k",
-    File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap()
-);
-
-make_spec_test!(
-    random_73k_test,
-    "random-73k",
-    File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap()
-);
-
-make_io_test!(
-    random_73k_test_not_a_multiple_obs_gt_ibs,
-    "random-73k-not-a-multiple-obs-gt-ibs",
-    Input {
-        src: File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap(),
-        non_ascii: false,
-        ibs: 521,
-        print_level: None,
-        count: None,
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1031,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap()
-);
-
-make_io_test!(
-    random_73k_test_obs_lt_not_a_multiple_ibs,
-    "random-73k-obs-lt-not-a-multiple-ibs",
-    Input {
-        src: File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap(),
-        non_ascii: false,
-        ibs: 1031,
-        print_level: None,
-        count: None,
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 521,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap()
-);
-
-make_io_test!(
-    deadbeef_all_32k_test_count_reads,
-    "deadbeef_all_32k_test_count_reads",
-    Input {
-        src: File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap(),
-        non_ascii: false,
-        ibs: 1024,
-        print_level: None,
-        count: Some(CountType::Reads(32)),
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1024,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap()
-);
-
-make_io_test!(
-    deadbeef_all_32k_test_count_bytes,
-    "deadbeef_all_32k_test_count_bytes",
-    Input {
-        src: File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap(),
-        non_ascii: false,
-        ibs: 531,
-        print_level: None,
-        count: Some(CountType::Bytes(32 * 1024)),
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1031,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap()
-);
-
-make_io_test!(
-    deadbeef_32k_to_16k_test_count_reads,
-    "deadbeef_32k_test_count_reads",
-    Input {
-        src: File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap(),
-        non_ascii: false,
-        ibs: 1024,
-        print_level: None,
-        count: Some(CountType::Reads(16)),
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1031,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/gnudd-deadbeef-first-16k.spec").unwrap()
-);
-
-make_io_test!(
-    deadbeef_32k_to_12345_test_count_bytes,
-    "deadbeef_32k_to_12345_test_count_bytes",
-    Input {
-        src: File::open("./test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test").unwrap(),
-        non_ascii: false,
-        ibs: 531,
-        print_level: None,
-        count: Some(CountType::Bytes(12345)),
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1031,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/gnudd-deadbeef-first-12345.spec").unwrap()
-);
-
-make_io_test!(
-    random_73k_test_count_reads,
-    "random-73k-test-count-reads",
-    Input {
-        src: File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap(),
-        non_ascii: false,
-        ibs: 1024,
-        print_level: None,
-        count: Some(CountType::Reads(32)),
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1024,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/gnudd-random-first-32k.spec").unwrap()
-);
-
-make_io_test!(
-    random_73k_test_count_bytes,
-    "random-73k-test-count-bytes",
-    Input {
-        src: File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap(),
-        non_ascii: false,
-        ibs: 521,
-        print_level: None,
-        count: Some(CountType::Bytes(32 * 1024)),
-        cflags: IConvFlags::default(),
-        iflags: IFlags::default(),
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1031,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/gnudd-random-first-32k.spec").unwrap()
-);
-
-make_io_test!(
-    random_73k_test_lazy_fullblock,
-    "random-73k-test-lazy-fullblock",
-    Input {
-        src: LazyReader {
-            src: File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test")
-                .unwrap()
-        },
-        non_ascii: false,
-        ibs: 521,
-        print_level: None,
-        count: None,
-        cflags: IConvFlags::default(),
-        iflags: IFlags {
-            fullblock: true,
-            ..IFlags::default()
-        },
-    },
-    Output {
-        dst: DST_PLACEHOLDER,
-        obs: 1031,
-        cflags: OConvFlags::default(),
-    },
-    File::open("./test-resources/random-5828891cb1230748e146f34223bbd3b5.test").unwrap()
-);
-
-// Test internal buffer size fn
-#[test]
-fn bsize_test_primes() {
-    let (n, m) = (7901, 7919);
-    let res = calc_bsize(n, m);
-    assert!(res % n == 0);
-    assert!(res % m == 0);
-
-    assert_eq!(res, n * m);
-}
-
-#[test]
-fn bsize_test_rel_prime_obs_greater() {
-    let (n, m) = (7 * 5119, 13 * 5119);
-    let res = calc_bsize(n, m);
-    assert!(res % n == 0);
-    assert!(res % m == 0);
-
-    assert_eq!(res, 7 * 13 * 5119);
-}
-
-#[test]
-fn bsize_test_rel_prime_ibs_greater() {
-    let (n, m) = (13 * 5119, 7 * 5119);
-    let res = calc_bsize(n, m);
-    assert!(res % n == 0);
-    assert!(res % m == 0);
-
-    assert_eq!(res, 7 * 13 * 5119);
-}
-
-#[test]
-fn bsize_test_3fac_rel_prime() {
-    let (n, m) = (11 * 13 * 5119, 7 * 11 * 5119);
-    let res = calc_bsize(n, m);
-    assert!(res % n == 0);
-    assert!(res % m == 0);
-
-    assert_eq!(res, 7 * 11 * 13 * 5119);
-}
-
-#[test]
-fn bsize_test_ibs_greater() {
-    let (n, m) = (512 * 1024, 256 * 1024);
-    let res = calc_bsize(n, m);
-    assert!(res % n == 0);
-    assert!(res % m == 0);
-
-    assert_eq!(res, n);
-}
-
-#[test]
-fn bsize_test_obs_greater() {
-    let (n, m) = (256 * 1024, 512 * 1024);
-    let res = calc_bsize(n, m);
-    assert!(res % n == 0);
-    assert!(res % m == 0);
-
-    assert_eq!(res, m);
-}
-
-#[test]
-fn bsize_test_bs_eq() {
-    let (n, m) = (1024, 1024);
-    let res = calc_bsize(n, m);
-    assert!(res % n == 0);
-    assert!(res % m == 0);
-
-    assert_eq!(res, m);
-}
-
-#[test]
-#[should_panic]
-fn test_nocreat_causes_failure_when_ofile_doesnt_exist() {
-    let args = vec![
-        String::from("dd"),
-        String::from("--conv=nocreat"),
-        String::from("--of=not-a-real.file"),
-    ];
-
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
-    let _ = Output::<File>::new(&matches).unwrap();
-}
diff --git a/src/uu/dd/src/main.rs b/src/uu/dd/src/main.rs
index fb6f5a6f5..267fe5a3e 100644
--- a/src/uu/dd/src/main.rs
+++ b/src/uu/dd/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_dd); // spell-checker:ignore procs uucore
+uucore::bin!(uu_dd); // spell-checker:ignore procs uucore
diff --git a/src/uu/dd/src/parseargs.rs b/src/uu/dd/src/parseargs.rs
index 3683023ac..4bc65bc1c 100644
--- a/src/uu/dd/src/parseargs.rs
+++ b/src/uu/dd/src/parseargs.rs
@@ -4,15 +4,18 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore ctty, ctable, iconvflags, oconvflags
+// spell-checker:ignore ctty, ctable, iseek, oseek, iconvflags, oconvflags parseargs
 
 #[cfg(test)]
 mod unit_tests;
 
 use super::*;
 use std::error::Error;
+use uucore::error::UError;
+use uucore::parse_size::ParseSizeError;
+use uucore::show_warning;
 
-pub type Matches = clap::ArgMatches<'static>;
+pub type Matches = ArgMatches;
 
 /// Parser Errors describe errors with parser input
 #[derive(Debug, PartialEq)]
@@ -20,7 +23,7 @@ pub enum ParseError {
     MultipleFmtTable,
     MultipleUCaseLCase,
     MultipleBlockUnblock,
-    MultipleExclNoCreat,
+    MultipleExclNoCreate,
     FlagNoMatch(String),
     ConvFlagNoMatch(String),
     MultiplierStringParseFailure(String),
@@ -28,6 +31,33 @@ pub enum ParseError {
     BlockUnblockWithoutCBS,
     StatusLevelNotRecognized(String),
     Unimplemented(String),
+    BsOutOfRange,
+    IbsOutOfRange,
+    ObsOutOfRange,
+    CbsOutOfRange,
+}
+
+impl ParseError {
+    /// Replace the argument, if any, with the given string, consuming self.
+    fn with_arg(self, s: String) -> Self {
+        match self {
+            Self::MultipleFmtTable => Self::MultipleFmtTable,
+            Self::MultipleUCaseLCase => Self::MultipleUCaseLCase,
+            Self::MultipleBlockUnblock => Self::MultipleBlockUnblock,
+            Self::MultipleExclNoCreate => Self::MultipleExclNoCreate,
+            Self::FlagNoMatch(_) => Self::FlagNoMatch(s),
+            Self::ConvFlagNoMatch(_) => Self::ConvFlagNoMatch(s),
+            Self::MultiplierStringParseFailure(_) => Self::MultiplierStringParseFailure(s),
+            Self::MultiplierStringOverflow(_) => Self::MultiplierStringOverflow(s),
+            Self::BlockUnblockWithoutCBS => Self::BlockUnblockWithoutCBS,
+            Self::StatusLevelNotRecognized(_) => Self::StatusLevelNotRecognized(s),
+            Self::Unimplemented(_) => Self::Unimplemented(s),
+            Self::BsOutOfRange => Self::BsOutOfRange,
+            Self::IbsOutOfRange => Self::IbsOutOfRange,
+            Self::ObsOutOfRange => Self::ObsOutOfRange,
+            Self::CbsOutOfRange => Self::CbsOutOfRange,
+        }
+    }
 }
 
 impl std::fmt::Display for ParseError {
@@ -45,7 +75,7 @@ impl std::fmt::Display for ParseError {
             Self::MultipleBlockUnblock => {
                 write!(f, "Only one of conv=block or conv=unblock may be specified")
             }
-            Self::MultipleExclNoCreat => {
+            Self::MultipleExclNoCreate => {
                 write!(f, "Only one ov conv=excl or conv=nocreat may be specified")
             }
             Self::FlagNoMatch(arg) => {
@@ -70,6 +100,18 @@ impl std::fmt::Display for ParseError {
             Self::StatusLevelNotRecognized(arg) => {
                 write!(f, "status=LEVEL not recognized -> {}", arg)
             }
+            Self::BsOutOfRange => {
+                write!(f, "bs=N cannot fit into memory")
+            }
+            Self::IbsOutOfRange => {
+                write!(f, "ibs=N cannot fit into memory")
+            }
+            Self::ObsOutOfRange => {
+                write!(f, "obs=N cannot fit into memory")
+            }
+            Self::CbsOutOfRange => {
+                write!(f, "cbs=N cannot fit into memory")
+            }
             Self::Unimplemented(arg) => {
                 write!(f, "feature not implemented on this system -> {}", arg)
             }
@@ -79,7 +121,13 @@ impl std::fmt::Display for ParseError {
 
 impl Error for ParseError {}
 
-/// Some flags specified as part of a conv=CONV[,CONV]... block
+impl UError for ParseError {
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+/// Some flags specified as part of a conv=CONV\[,CONV\]... block
 /// relate to the input file, others to the output file.
 #[derive(Debug, PartialEq)]
 enum ConvFlag {
@@ -289,49 +337,130 @@ impl std::str::FromStr for StatusLevel {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "none" => Ok(StatusLevel::None),
-            "noxfer" => Ok(StatusLevel::Noxfer),
-            "progress" => Ok(StatusLevel::Progress),
+            "none" => Ok(Self::None),
+            "noxfer" => Ok(Self::Noxfer),
+            "progress" => Ok(Self::Progress),
             _ => Err(ParseError::StatusLevelNotRecognized(s.to_string())),
         }
     }
 }
 
+fn show_zero_multiplier_warning() {
+    show_warning!(
+        "{} is a zero multiplier; use {} if that is intended",
+        "0x".quote(),
+        "00x".quote()
+    );
+}
+
 /// Parse bytes using str::parse, then map error if needed.
-fn parse_bytes_only(s: &str) -> Result<usize, ParseError> {
+fn parse_bytes_only(s: &str) -> Result<u64, ParseError> {
     s.parse()
         .map_err(|_| ParseError::MultiplierStringParseFailure(s.to_string()))
 }
 
+/// Parse a number of bytes from the given string, assuming no `'x'` characters.
+///
+/// The `'x'` character means "multiply the number before the `'x'` by
+/// the number after the `'x'`". In order to compute the numbers
+/// before and after the `'x'`, use this function, which assumes there
+/// are no `'x'` characters in the string.
+///
+/// A suffix `'c'` means multiply by 1, `'w'` by 2, and `'b'` by
+/// 512. You can also use standard block size suffixes like `'k'` for
+/// 1024.
+///
+/// # Errors
+///
+/// If a number cannot be parsed or if the multiplication would cause
+/// an overflow.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// assert_eq!(parse_bytes_no_x("123").unwrap(), 123);
+/// assert_eq!(parse_bytes_no_x("2c").unwrap(), 2 * 1);
+/// assert_eq!(parse_bytes_no_x("3w").unwrap(), 3 * 2);
+/// assert_eq!(parse_bytes_no_x("2b").unwrap(), 2 * 512);
+/// assert_eq!(parse_bytes_no_x("2k").unwrap(), 2 * 1024);
+/// ```
+fn parse_bytes_no_x(s: &str) -> Result<u64, ParseError> {
+    let (num, multiplier) = match (s.find('c'), s.rfind('w'), s.rfind('b')) {
+        (None, None, None) => match uucore::parse_size::parse_size(s) {
+            Ok(n) => (n, 1),
+            Err(ParseSizeError::ParseFailure(s)) => {
+                return Err(ParseError::MultiplierStringParseFailure(s))
+            }
+            Err(ParseSizeError::SizeTooBig(s)) => {
+                return Err(ParseError::MultiplierStringOverflow(s))
+            }
+        },
+        (Some(i), None, None) => (parse_bytes_only(&s[..i])?, 1),
+        (None, Some(i), None) => (parse_bytes_only(&s[..i])?, 2),
+        (None, None, Some(i)) => (parse_bytes_only(&s[..i])?, 512),
+        _ => return Err(ParseError::MultiplierStringParseFailure(s.to_string())),
+    };
+    num.checked_mul(multiplier)
+        .ok_or_else(|| ParseError::MultiplierStringOverflow(s.to_string()))
+}
+
 /// Parse byte and multiplier like 512, 5KiB, or 1G.
 /// Uses uucore::parse_size, and adds the 'w' and 'c' suffixes which are mentioned
 /// in dd's info page.
-fn parse_bytes_with_opt_multiplier(s: &str) -> Result<usize, ParseError> {
-    if let Some(idx) = s.rfind('c') {
-        parse_bytes_only(&s[..idx])
-    } else if let Some(idx) = s.rfind('w') {
-        let partial = parse_bytes_only(&s[..idx])?;
+fn parse_bytes_with_opt_multiplier(s: &str) -> Result<u64, ParseError> {
+    // TODO On my Linux system, there seems to be a maximum block size of 4096 bytes:
+    //
+    //     $ printf "%0.sa" {1..10000} | dd bs=4095 count=1 status=none | wc -c
+    //     4095
+    //     $ printf "%0.sa" {1..10000} | dd bs=4k count=1 status=none | wc -c
+    //     4096
+    //     $ printf "%0.sa" {1..10000} | dd bs=4097 count=1 status=none | wc -c
+    //     4096
+    //     $ printf "%0.sa" {1..10000} | dd bs=5k count=1 status=none | wc -c
+    //     4096
+    //
 
-        partial
-            .checked_mul(2)
-            .ok_or_else(|| ParseError::MultiplierStringOverflow(s.to_string()))
+    // Split on the 'x' characters. Each component will be parsed
+    // individually, then multiplied together.
+    let parts: Vec<&str> = s.split('x').collect();
+    if parts.len() == 1 {
+        parse_bytes_no_x(parts[0]).map_err(|e| e.with_arg(s.to_string()))
     } else {
-        uucore::parse_size::parse_size(s).map_err(|e| match e {
-            uucore::parse_size::ParseSizeError::ParseFailure(s) => {
-                ParseError::MultiplierStringParseFailure(s)
+        let mut total = 1;
+        for part in parts {
+            if part == "0" {
+                show_zero_multiplier_warning();
             }
-            uucore::parse_size::ParseSizeError::SizeTooBig(s) => {
-                ParseError::MultiplierStringOverflow(s)
-            }
-        })
+            let num = parse_bytes_no_x(part).map_err(|e| e.with_arg(s.to_string()))?;
+            total *= num;
+        }
+        Ok(total)
     }
 }
 
 pub fn parse_ibs(matches: &Matches) -> Result<usize, ParseError> {
     if let Some(mixed_str) = matches.value_of(options::BS) {
-        parse_bytes_with_opt_multiplier(mixed_str)
+        parse_bytes_with_opt_multiplier(mixed_str)?
+            .try_into()
+            .map_err(|_| ParseError::BsOutOfRange)
     } else if let Some(mixed_str) = matches.value_of(options::IBS) {
-        parse_bytes_with_opt_multiplier(mixed_str)
+        parse_bytes_with_opt_multiplier(mixed_str)?
+            .try_into()
+            .map_err(|_| ParseError::IbsOutOfRange)
+    } else {
+        Ok(512)
+    }
+}
+
+pub fn parse_obs(matches: &Matches) -> Result<usize, ParseError> {
+    if let Some(mixed_str) = matches.value_of("bs") {
+        parse_bytes_with_opt_multiplier(mixed_str)?
+            .try_into()
+            .map_err(|_| ParseError::BsOutOfRange)
+    } else if let Some(mixed_str) = matches.value_of("obs") {
+        parse_bytes_with_opt_multiplier(mixed_str)?
+            .try_into()
+            .map_err(|_| ParseError::ObsOutOfRange)
     } else {
         Ok(512)
     }
@@ -339,14 +468,16 @@ pub fn parse_ibs(matches: &Matches) -> Result<usize, ParseError> {
 
 fn parse_cbs(matches: &Matches) -> Result<Option<usize>, ParseError> {
     if let Some(s) = matches.value_of(options::CBS) {
-        let bytes = parse_bytes_with_opt_multiplier(s)?;
+        let bytes = parse_bytes_with_opt_multiplier(s)?
+            .try_into()
+            .map_err(|_| ParseError::CbsOutOfRange)?;
         Ok(Some(bytes))
     } else {
         Ok(None)
     }
 }
 
-pub fn parse_status_level(matches: &Matches) -> Result<Option<StatusLevel>, ParseError> {
+pub(crate) fn parse_status_level(matches: &Matches) -> Result<Option<StatusLevel>, ParseError> {
     match matches.value_of(options::STATUS) {
         Some(s) => {
             let st = s.parse()?;
@@ -356,16 +487,6 @@ pub fn parse_status_level(matches: &Matches) -> Result<Option<StatusLevel>, Pars
     }
 }
 
-pub fn parse_obs(matches: &Matches) -> Result<usize, ParseError> {
-    if let Some(mixed_str) = matches.value_of("bs") {
-        parse_bytes_with_opt_multiplier(mixed_str)
-    } else if let Some(mixed_str) = matches.value_of("obs") {
-        parse_bytes_with_opt_multiplier(mixed_str)
-    } else {
-        Ok(512)
-    }
-}
-
 fn parse_ctable(fmt: Option<ConvFlag>, case: Option<ConvFlag>) -> Option<&'static ConversionTable> {
     fn parse_conv_and_case_table(
         fmt: &ConvFlag,
@@ -407,21 +528,57 @@ fn parse_flag_list<T: std::str::FromStr<Err = ParseError>>(
     tag: &str,
     matches: &Matches,
 ) -> Result<Vec<T>, ParseError> {
-    let mut flags = Vec::new();
+    matches
+        .values_of(tag)
+        .unwrap_or_default()
+        .map(|f| f.parse())
+        .collect()
+}
 
-    if let Some(comma_str) = matches.value_of(tag) {
-        for s in comma_str.split(',') {
-            let flag = s.parse()?;
-            flags.push(flag);
+/// Given the various command-line parameters, determine the conversion mode.
+///
+/// The `conv` command-line option can take many different values,
+/// each of which may combine with others. For example, `conv=ascii`,
+/// `conv=lcase`, `conv=sync`, and so on. The arguments to this
+/// function represent the settings of those various command-line
+/// parameters. This function translates those settings to a
+/// [`ConversionMode`].
+fn conversion_mode(
+    ctable: Option<&ConversionTable>,
+    block: Option<usize>,
+    unblock: Option<usize>,
+    non_ascii: bool,
+    is_sync: bool,
+) -> Option<ConversionMode> {
+    match (ctable, block, unblock) {
+        (Some(ct), None, None) => Some(ConversionMode::ConvertOnly(ct)),
+        (Some(ct), Some(cbs), None) => {
+            if non_ascii {
+                Some(ConversionMode::ConvertThenBlock(ct, cbs, is_sync))
+            } else {
+                Some(ConversionMode::BlockThenConvert(ct, cbs, is_sync))
+            }
         }
+        (Some(ct), None, Some(cbs)) => {
+            if non_ascii {
+                Some(ConversionMode::ConvertThenUnblock(ct, cbs))
+            } else {
+                Some(ConversionMode::UnblockThenConvert(ct, cbs))
+            }
+        }
+        (None, Some(cbs), None) => Some(ConversionMode::BlockOnly(cbs, is_sync)),
+        (None, None, Some(cbs)) => Some(ConversionMode::UnblockOnly(cbs)),
+        (None, None, None) => None,
+        // The remaining variants should never happen because the
+        // argument parsing above should result in an error before
+        // getting to this line of code.
+        _ => unreachable!(),
     }
-
-    Ok(flags)
 }
 
 /// Parse Conversion Options (Input Variety)
 /// Construct and validate a IConvFlags
-pub fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError> {
+pub(crate) fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError> {
     let mut iconvflags = IConvFlags::default();
     let mut fmt = None;
     let mut case = None;
@@ -430,6 +587,9 @@ pub fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError
     let flags = parse_flag_list(options::CONV, matches)?;
     let cbs = parse_cbs(matches)?;
 
+    let mut block = None;
+    let mut unblock = None;
+
     for flag in flags {
         match flag {
             ConvFlag::FmtEtoA => {
@@ -437,6 +597,20 @@ pub fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError
                     return Err(ParseError::MultipleFmtTable);
                 } else {
                     fmt = Some(flag);
+                    // From the GNU documentation:
+                    //
+                    // > ‘ascii’
+                    // >
+                    // > Convert EBCDIC to ASCII, using the conversion
+                    // > table specified by POSIX. This provides a 1:1
+                    // > translation for all 256 bytes. This implies
+                    // > ‘conv=unblock’; input is converted to ASCII
+                    // > before trailing spaces are deleted.
+                    //
+                    // -- https://www.gnu.org/software/coreutils/manual/html_node/dd-invocation.html
+                    if cbs.is_some() {
+                        unblock = cbs;
+                    }
                 }
             }
             ConvFlag::FmtAtoE => {
@@ -444,6 +618,19 @@ pub fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError
                     return Err(ParseError::MultipleFmtTable);
                 } else {
                     fmt = Some(flag);
+                    // From the GNU documentation:
+                    //
+                    // > ‘ebcdic’
+                    // >
+                    // > Convert ASCII to EBCDIC. This is the inverse
+                    // > of the ‘ascii’ conversion. This implies
+                    // > ‘conv=block’; trailing spaces are added before
+                    // > being converted to EBCDIC.
+                    //
+                    // -- https://www.gnu.org/software/coreutils/manual/html_node/dd-invocation.html
+                    if cbs.is_some() {
+                        block = cbs;
+                    }
                 }
             }
             ConvFlag::FmtAtoI => {
@@ -453,27 +640,20 @@ pub fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError
                     fmt = Some(flag);
                 }
             }
-            ConvFlag::UCase => {
+            ConvFlag::UCase | ConvFlag::LCase => {
                 if case.is_some() {
                     return Err(ParseError::MultipleUCaseLCase);
                 } else {
-                    case = Some(flag)
+                    case = Some(flag);
                 }
             }
-            ConvFlag::LCase => {
-                if case.is_some() {
-                    return Err(ParseError::MultipleUCaseLCase);
-                } else {
-                    case = Some(flag)
-                }
-            }
-            ConvFlag::Block => match (cbs, iconvflags.unblock) {
-                (Some(cbs), None) => iconvflags.block = Some(cbs),
+            ConvFlag::Block => match (cbs, unblock) {
+                (Some(cbs), None) => block = Some(cbs),
                 (None, _) => return Err(ParseError::BlockUnblockWithoutCBS),
                 (_, Some(_)) => return Err(ParseError::MultipleBlockUnblock),
             },
-            ConvFlag::Unblock => match (cbs, iconvflags.block) {
-                (Some(cbs), None) => iconvflags.unblock = Some(cbs),
+            ConvFlag::Unblock => match (cbs, block) {
+                (Some(cbs), None) => unblock = Some(cbs),
                 (None, _) => return Err(ParseError::BlockUnblockWithoutCBS),
                 (_, Some(_)) => return Err(ParseError::MultipleBlockUnblock),
             },
@@ -494,7 +674,7 @@ pub fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError
     // block implies sync with ' '
     // unblock implies sync with 0
     // So the final value can't be set until all flags are parsed.
-    let sync = if is_sync && (iconvflags.block.is_some() || iconvflags.unblock.is_some()) {
+    let sync = if is_sync && (block.is_some() || unblock.is_some()) {
         Some(b' ')
     } else if is_sync {
         Some(0u8)
@@ -502,8 +682,27 @@ pub fn parse_conv_flag_input(matches: &Matches) -> Result<IConvFlags, ParseError
         None
     };
 
+    // Some user options, such as the presence of conversion tables,
+    // will determine whether the input is assumed to be ascii. This
+    // parser sets the non_ascii flag accordingly.
+    //
+    // Examples:
+    //
+    // - If conv=ebcdic or conv=ibm is specified then block,
+    //   unblock or swab must be performed before the conversion
+    //   happens since the source will start in ascii.
+    // - If conv=ascii is specified then block, unblock or swab
+    //   must be performed after the conversion since the source
+    //   starts in ebcdic.
+    // - If no conversion is specified then the source is assumed
+    //   to be in ascii.
+    //
+    // For more info see `info dd`.
+    let non_ascii = parseargs::parse_input_non_ascii(matches)?;
+    let mode = conversion_mode(ctable, block, unblock, non_ascii, is_sync);
+
     Ok(IConvFlags {
-        ctable,
+        mode,
         sync,
         ..iconvflags
     })
@@ -523,14 +722,14 @@ pub fn parse_conv_flag_output(matches: &Matches) -> Result<OConvFlags, ParseErro
                 if !oconvflags.nocreat {
                     oconvflags.excl = true;
                 } else {
-                    return Err(ParseError::MultipleExclNoCreat);
+                    return Err(ParseError::MultipleExclNoCreate);
                 }
             }
             ConvFlag::NoCreat => {
                 if !oconvflags.excl {
                     oconvflags.nocreat = true;
                 } else {
-                    return Err(ParseError::MultipleExclNoCreat);
+                    return Err(ParseError::MultipleExclNoCreate);
                 }
             }
             ConvFlag::NoTrunc => oconvflags.notrunc = true,
@@ -604,36 +803,18 @@ pub fn parse_oflags(matches: &Matches) -> Result<OFlags, ParseError> {
     Ok(oflags)
 }
 
-/// Parse the amount of the input file to skip.
-pub fn parse_skip_amt(
+pub fn parse_seek_skip_amt(
     ibs: &usize,
-    iflags: &IFlags,
+    bytes: bool,
     matches: &Matches,
-) -> Result<Option<usize>, ParseError> {
-    if let Some(amt) = matches.value_of(options::SKIP) {
+    option: &str,
+) -> Result<Option<u64>, ParseError> {
+    if let Some(amt) = matches.value_of(option) {
         let n = parse_bytes_with_opt_multiplier(amt)?;
-        if iflags.skip_bytes {
+        if bytes {
             Ok(Some(n))
         } else {
-            Ok(Some(ibs * n))
-        }
-    } else {
-        Ok(None)
-    }
-}
-
-/// Parse the amount of the output file to seek.
-pub fn parse_seek_amt(
-    obs: &usize,
-    oflags: &OFlags,
-    matches: &Matches,
-) -> Result<Option<usize>, ParseError> {
-    if let Some(amt) = matches.value_of(options::SEEK) {
-        let n = parse_bytes_with_opt_multiplier(amt)?;
-        if oflags.seek_bytes {
-            Ok(Some(n))
-        } else {
-            Ok(Some(obs * n))
+            Ok(Some(*ibs as u64 * n))
         }
     } else {
         Ok(None)
@@ -662,3 +843,26 @@ pub fn parse_input_non_ascii(matches: &Matches) -> Result<bool, ParseError> {
         Ok(false)
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::parseargs::parse_bytes_with_opt_multiplier;
+
+    #[test]
+    fn test_parse_bytes_with_opt_multiplier() {
+        assert_eq!(parse_bytes_with_opt_multiplier("123").unwrap(), 123);
+        assert_eq!(parse_bytes_with_opt_multiplier("123c").unwrap(), 123); // 123 * 1
+        assert_eq!(parse_bytes_with_opt_multiplier("123w").unwrap(), 123 * 2);
+        assert_eq!(parse_bytes_with_opt_multiplier("123b").unwrap(), 123 * 512);
+        assert_eq!(parse_bytes_with_opt_multiplier("123x3").unwrap(), 123 * 3);
+        assert_eq!(parse_bytes_with_opt_multiplier("123k").unwrap(), 123 * 1024);
+        assert_eq!(parse_bytes_with_opt_multiplier("1x2x3").unwrap(), 6); // 1 * 2 * 3
+
+        assert_eq!(
+            parse_bytes_with_opt_multiplier("1wx2cx3w").unwrap(),
+            2 * 2 * (3 * 2) // (1 * 2) * (2 * 1) * (3 * 2)
+        );
+        assert!(parse_bytes_with_opt_multiplier("123asdf").is_err());
+    }
+}
diff --git a/src/uu/dd/src/parseargs/unit_tests.rs b/src/uu/dd/src/parseargs/unit_tests.rs
index 21900ee49..6a2ea5b54 100644
--- a/src/uu/dd/src/parseargs/unit_tests.rs
+++ b/src/uu/dd/src/parseargs/unit_tests.rs
@@ -1,4 +1,4 @@
-// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, behaviour, bmax, bremain, btotal, cflags, creat, ctable, ctty, datastructures, doesnt, etoa, fileout, fname, gnudd, iconvflags, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
+// spell-checker:ignore fname, tname, fpath, specfile, testfile, unspec, ifile, ofile, outfile, fullblock, urand, fileio, atoe, atoibm, 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
 
 use super::*;
 
@@ -25,7 +25,7 @@ fn unimplemented_flags_should_error_non_linux() {
             format!("--iflag={}", flag),
             format!("--oflag={}", flag),
         ];
-        let matches = uu_app().get_matches_from_safe(args).unwrap();
+        let matches = uu_app().try_get_matches_from(args).unwrap();
 
         if parse_iflags(&matches).is_ok() {
             succeeded.push(format!("iflag={}", flag));
@@ -53,13 +53,13 @@ fn unimplemented_flags_should_error() {
             format!("--iflag={}", flag),
             format!("--oflag={}", flag),
         ];
-        let matches = uu_app().get_matches_from_safe(args).unwrap();
+        let matches = uu_app().try_get_matches_from(args).unwrap();
 
         if parse_iflags(&matches).is_ok() {
-            succeeded.push(format!("iflag={}", flag))
+            succeeded.push(format!("iflag={}", flag));
         }
         if parse_oflags(&matches).is_ok() {
-            succeeded.push(format!("oflag={}", flag))
+            succeeded.push(format!("oflag={}", flag));
         }
     }
 
@@ -78,7 +78,7 @@ fn test_status_level_absent() {
         String::from("--of=bar.file"),
     ];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
     let st = parse_status_level(&matches).unwrap();
 
     assert_eq!(st, None);
@@ -93,7 +93,7 @@ fn test_status_level_none() {
         String::from("--of=bar.file"),
     ];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
     let st = parse_status_level(&matches).unwrap().unwrap();
 
     assert_eq!(st, StatusLevel::None);
@@ -112,6 +112,8 @@ fn test_all_top_level_args_no_leading_dashes() {
         String::from("count=2"),
         String::from("skip=2"),
         String::from("seek=2"),
+        String::from("iseek=2"),
+        String::from("oseek=2"),
         String::from("status=progress"),
         String::from("conv=ascii,ucase"),
         String::from("iflag=count_bytes,skip_bytes"),
@@ -121,7 +123,7 @@ fn test_all_top_level_args_no_leading_dashes() {
         .into_iter()
         .fold(Vec::new(), append_dashes_if_not_present);
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     assert_eq!(100, parse_ibs(&matches).unwrap());
     assert_eq!(100, parse_obs(&matches).unwrap());
@@ -140,13 +142,25 @@ fn test_all_top_level_args_no_leading_dashes() {
     );
     assert_eq!(
         200,
-        parse_skip_amt(&100, &IFlags::default(), &matches)
+        parse_seek_skip_amt(&100, IFlags::default().skip_bytes, &matches, options::SKIP)
             .unwrap()
             .unwrap()
     );
     assert_eq!(
         200,
-        parse_seek_amt(&100, &OFlags::default(), &matches)
+        parse_seek_skip_amt(&100, OFlags::default().seek_bytes, &matches, options::SEEK)
+            .unwrap()
+            .unwrap()
+    );
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, IFlags::default().skip_bytes, &matches, options::ISEEK)
+            .unwrap()
+            .unwrap()
+    );
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, OFlags::default().seek_bytes, &matches, options::OSEEK)
             .unwrap()
             .unwrap()
     );
@@ -156,7 +170,11 @@ fn test_all_top_level_args_no_leading_dashes() {
     );
     assert_eq!(
         IConvFlags {
-            ctable: Some(&EBCDIC_TO_ASCII_LCASE_TO_UCASE),
+            // ascii implies unblock
+            mode: Some(ConversionMode::ConvertThenUnblock(
+                &EBCDIC_TO_ASCII_LCASE_TO_UCASE,
+                1
+            )),
             ..IConvFlags::default()
         },
         parse_conv_flag_input(&matches).unwrap()
@@ -196,6 +214,8 @@ fn test_all_top_level_args_with_leading_dashes() {
         String::from("--count=2"),
         String::from("--skip=2"),
         String::from("--seek=2"),
+        String::from("--iseek=2"),
+        String::from("--oseek=2"),
         String::from("--status=progress"),
         String::from("--conv=ascii,ucase"),
         String::from("--iflag=count_bytes,skip_bytes"),
@@ -205,7 +225,7 @@ fn test_all_top_level_args_with_leading_dashes() {
         .into_iter()
         .fold(Vec::new(), append_dashes_if_not_present);
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     assert_eq!(100, parse_ibs(&matches).unwrap());
     assert_eq!(100, parse_obs(&matches).unwrap());
@@ -224,13 +244,25 @@ fn test_all_top_level_args_with_leading_dashes() {
     );
     assert_eq!(
         200,
-        parse_skip_amt(&100, &IFlags::default(), &matches)
+        parse_seek_skip_amt(&100, IFlags::default().skip_bytes, &matches, options::SKIP)
             .unwrap()
             .unwrap()
     );
     assert_eq!(
         200,
-        parse_seek_amt(&100, &OFlags::default(), &matches)
+        parse_seek_skip_amt(&100, OFlags::default().seek_bytes, &matches, options::SEEK)
+            .unwrap()
+            .unwrap()
+    );
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, IFlags::default().skip_bytes, &matches, options::ISEEK)
+            .unwrap()
+            .unwrap()
+    );
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, OFlags::default().seek_bytes, &matches, options::OSEEK)
             .unwrap()
             .unwrap()
     );
@@ -240,7 +272,11 @@ fn test_all_top_level_args_with_leading_dashes() {
     );
     assert_eq!(
         IConvFlags {
-            ctable: Some(&EBCDIC_TO_ASCII_LCASE_TO_UCASE),
+            // ascii implies unblock
+            mode: Some(ConversionMode::ConvertThenUnblock(
+                &EBCDIC_TO_ASCII_LCASE_TO_UCASE,
+                1
+            )),
             ..IConvFlags::default()
         },
         parse_conv_flag_input(&matches).unwrap()
@@ -276,7 +312,7 @@ fn test_status_level_progress() {
         String::from("--status=progress"),
     ];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
     let st = parse_status_level(&matches).unwrap().unwrap();
 
     assert_eq!(st, StatusLevel::Progress);
@@ -291,12 +327,142 @@ fn test_status_level_noxfer() {
         String::from("--of=bar.file"),
     ];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
     let st = parse_status_level(&matches).unwrap().unwrap();
 
     assert_eq!(st, StatusLevel::Noxfer);
 }
 
+#[test]
+fn test_multiple_flags_options() {
+    let args = vec![
+        String::from("dd"),
+        String::from("--iflag=fullblock,count_bytes"),
+        String::from("--iflag=skip_bytes"),
+        String::from("--oflag=append"),
+        String::from("--oflag=seek_bytes"),
+        String::from("--conv=ascii,ucase"),
+        String::from("--conv=unblock"),
+    ];
+    let matches = uu_app().try_get_matches_from(args).unwrap();
+
+    // iflag
+    let iflags = parse_flag_list::<Flag>(options::IFLAG, &matches).unwrap();
+    assert_eq!(
+        vec![Flag::FullBlock, Flag::CountBytes, Flag::SkipBytes],
+        iflags
+    );
+
+    // oflag
+    let oflags = parse_flag_list::<Flag>(options::OFLAG, &matches).unwrap();
+    assert_eq!(vec![Flag::Append, Flag::SeekBytes], oflags);
+
+    // conv
+    let conv = parse_flag_list::<ConvFlag>(options::CONV, &matches).unwrap();
+    assert_eq!(
+        vec![ConvFlag::FmtEtoA, ConvFlag::UCase, ConvFlag::Unblock],
+        conv
+    );
+}
+
+#[test]
+fn test_override_multiple_options() {
+    let args = vec![
+        String::from("dd"),
+        String::from("--if=foo.file"),
+        String::from("--if=correct.file"),
+        String::from("--of=bar.file"),
+        String::from("--of=correct.file"),
+        String::from("--ibs=256"),
+        String::from("--ibs=1024"),
+        String::from("--obs=256"),
+        String::from("--obs=1024"),
+        String::from("--cbs=1"),
+        String::from("--cbs=2"),
+        String::from("--skip=0"),
+        String::from("--skip=2"),
+        String::from("--seek=0"),
+        String::from("--seek=2"),
+        String::from("--iseek=0"),
+        String::from("--iseek=2"),
+        String::from("--oseek=0"),
+        String::from("--oseek=2"),
+        String::from("--status=none"),
+        String::from("--status=noxfer"),
+        String::from("--count=512"),
+        String::from("--count=1024"),
+    ];
+
+    let matches = uu_app().try_get_matches_from(args).unwrap();
+
+    // if
+    assert_eq!("correct.file", matches.value_of(options::INFILE).unwrap());
+
+    // of
+    assert_eq!("correct.file", matches.value_of(options::OUTFILE).unwrap());
+
+    // ibs
+    assert_eq!(1024, parse_ibs(&matches).unwrap());
+
+    // obs
+    assert_eq!(1024, parse_obs(&matches).unwrap());
+
+    // cbs
+    assert_eq!(2, parse_cbs(&matches).unwrap().unwrap());
+
+    // status
+    assert_eq!(
+        StatusLevel::Noxfer,
+        parse_status_level(&matches).unwrap().unwrap()
+    );
+
+    // skip
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, IFlags::default().skip_bytes, &matches, options::SKIP)
+            .unwrap()
+            .unwrap()
+    );
+
+    // seek
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, OFlags::default().seek_bytes, &matches, options::SEEK)
+            .unwrap()
+            .unwrap()
+    );
+
+    // iseek
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, IFlags::default().skip_bytes, &matches, options::ISEEK)
+            .unwrap()
+            .unwrap()
+    );
+
+    // oseek
+    assert_eq!(
+        200,
+        parse_seek_skip_amt(&100, OFlags::default().seek_bytes, &matches, options::OSEEK)
+            .unwrap()
+            .unwrap()
+    );
+
+    // count
+    assert_eq!(
+        CountType::Bytes(1024),
+        parse_count(
+            &IFlags {
+                count_bytes: true,
+                ..IFlags::default()
+            },
+            &matches
+        )
+        .unwrap()
+        .unwrap()
+    );
+}
+
 // ----- IConvFlags/Output -----
 
 #[test]
@@ -304,7 +470,7 @@ fn test_status_level_noxfer() {
 fn icf_ctable_error() {
     let args = vec![String::from("dd"), String::from("--conv=ascii,ebcdic,ibm")];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let _ = parse_conv_flag_input(&matches).unwrap();
 }
@@ -314,7 +480,7 @@ fn icf_ctable_error() {
 fn icf_case_error() {
     let args = vec![String::from("dd"), String::from("--conv=ucase,lcase")];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let _ = parse_conv_flag_input(&matches).unwrap();
 }
@@ -324,7 +490,7 @@ fn icf_case_error() {
 fn icf_block_error() {
     let args = vec![String::from("dd"), String::from("--conv=block,unblock")];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let _ = parse_conv_flag_input(&matches).unwrap();
 }
@@ -334,7 +500,7 @@ fn icf_block_error() {
 fn icf_creat_error() {
     let args = vec![String::from("dd"), String::from("--conv=excl,nocreat")];
 
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let _ = parse_conv_flag_output(&matches).unwrap();
 }
@@ -344,7 +510,7 @@ fn parse_icf_token_ibm() {
     let exp = vec![ConvFlag::FmtAtoI];
 
     let args = vec![String::from("dd"), String::from("--conv=ibm")];
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let act = parse_flag_list::<ConvFlag>("conv", &matches).unwrap();
 
@@ -362,7 +528,7 @@ fn parse_icf_tokens_elu() {
         String::from("dd"),
         String::from("--conv=ebcdic,lcase,unblock"),
     ];
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
     let act = parse_flag_list::<ConvFlag>("conv", &matches).unwrap();
 
     assert_eq!(exp.len(), act.len());
@@ -393,7 +559,7 @@ fn parse_icf_tokens_remaining() {
         String::from("dd"),
         String::from("--conv=ascii,ucase,block,sparse,swab,sync,noerror,excl,nocreat,notrunc,noerror,fdatasync,fsync"),
     ];
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let act = parse_flag_list::<ConvFlag>("conv", &matches).unwrap();
 
@@ -417,7 +583,7 @@ fn parse_iflag_tokens() {
         String::from("dd"),
         String::from("--iflag=fullblock,count_bytes,skip_bytes,append,seek_bytes"),
     ];
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let act = parse_flag_list::<Flag>("iflag", &matches).unwrap();
 
@@ -441,7 +607,7 @@ fn parse_oflag_tokens() {
         String::from("dd"),
         String::from("--oflag=fullblock,count_bytes,skip_bytes,append,seek_bytes"),
     ];
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let act = parse_flag_list::<Flag>("oflag", &matches).unwrap();
 
@@ -469,7 +635,7 @@ fn parse_iflag_tokens_linux() {
         String::from("dd"),
         String::from("--iflag=direct,directory,dsync,sync,nonblock,noatime,noctty,nofollow"),
     ];
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let act = parse_flag_list::<Flag>("iflag", &matches).unwrap();
 
@@ -497,7 +663,7 @@ fn parse_oflag_tokens_linux() {
         String::from("dd"),
         String::from("--oflag=direct,directory,dsync,sync,nonblock,noatime,noctty,nofollow"),
     ];
-    let matches = uu_app().get_matches_from_safe(args).unwrap();
+    let matches = uu_app().try_get_matches_from(args).unwrap();
 
     let act = parse_flag_list::<Flag>("oflag", &matches).unwrap();
 
@@ -573,7 +739,7 @@ mod test_64bit_arch {
 #[test]
 #[should_panic]
 fn test_overflow_panic() {
-    let bs_str = format!("{}KiB", usize::MAX);
+    let bs_str = format!("{}KiB", u64::MAX);
 
     parse_bytes_with_opt_multiplier(&bs_str).unwrap();
 }
diff --git a/src/uu/dd/src/progress.rs b/src/uu/dd/src/progress.rs
new file mode 100644
index 000000000..46369d291
--- /dev/null
+++ b/src/uu/dd/src/progress.rs
@@ -0,0 +1,517 @@
+//  * 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 btotal sigval
+//! Read and write progress tracking for dd.
+//!
+//! The [`ProgUpdate`] struct represents summary statistics for the
+//! read and write progress of a running `dd` process. The
+//! [`gen_prog_updater`] function can be used to implement a progress
+//! updater that runs in its own thread.
+use std::io::Write;
+use std::sync::mpsc;
+use std::time::Duration;
+
+use byte_unit::Byte;
+
+// On Linux, we register a signal handler that prints progress updates.
+#[cfg(target_os = "linux")]
+use signal_hook::consts::signal;
+#[cfg(target_os = "linux")]
+use std::{
+    env,
+    error::Error,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
+
+/// Summary statistics for read and write progress of dd for a given duration.
+pub(crate) struct ProgUpdate {
+    /// Read statistics.
+    ///
+    /// This contains information about the number of blocks read from
+    /// the data source.
+    pub(crate) read_stat: ReadStat,
+
+    /// Write statistics.
+    ///
+    /// This contains information about the number of blocks and
+    /// number of bytes written to the data sink.
+    pub(crate) write_stat: WriteStat,
+
+    /// The time period over which the reads and writes were measured.
+    pub(crate) duration: Duration,
+}
+
+impl ProgUpdate {
+    /// Instantiate this struct.
+    pub(crate) fn new(read_stat: ReadStat, write_stat: WriteStat, duration: Duration) -> Self {
+        Self {
+            read_stat,
+            write_stat,
+            duration,
+        }
+    }
+
+    /// Write the number of complete and partial records both read and written.
+    ///
+    /// The information is written to `w`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// use std::io::Cursor;
+    /// use std::time::Duration;
+    /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+    ///
+    /// let read_stat = ReadStat::new(1, 2, 3);
+    /// let write_stat = WriteStat::new(4, 5, 6);
+    /// let duration = Duration::new(789, 0);
+    /// let prog_update = ProgUpdate {
+    ///     read_stat,
+    ///     write_stat,
+    ///     duration,
+    /// };
+    ///
+    /// let mut cursor = Cursor::new(vec![]);
+    /// prog_update.write_io_lines(&mut cursor).unwrap();
+    /// assert_eq!(
+    ///     cursor.get_ref(),
+    ///     b"1+2 records in\n3 truncated records\n4+5 records out\n"
+    /// );
+    /// ```
+    fn write_io_lines(&self, w: &mut impl Write) -> std::io::Result<()> {
+        self.read_stat.report(w)?;
+        self.write_stat.report(w)?;
+        match self.read_stat.records_truncated {
+            0 => {}
+            1 => writeln!(w, "1 truncated record")?,
+            n => writeln!(w, "{} truncated records", n)?,
+        }
+        Ok(())
+    }
+
+    /// Write the number of bytes written, duration, and throughput.
+    ///
+    /// The information is written to `w`. If `rewrite` is `true`,
+    /// then a `\r` character is written first and no newline is
+    /// written at the end. When writing to `stderr`, this has the
+    /// visual effect of overwriting the previous characters on the
+    /// line.
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// use std::io::Cursor;
+    /// use std::time::Duration;
+    /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+    ///
+    /// let prog_update = ProgUpdate {
+    ///     read_stat: Default::default(),
+    ///     write_stat: Default::default(),
+    ///     duration: Duration::new(1, 0),  // one second
+    /// };
+    ///
+    /// let mut cursor = Cursor::new(vec![]);
+    /// let rewrite = false;
+    /// prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
+    /// assert_eq!(
+    ///     cursor.get_ref(),
+    ///     b"0 bytes (0 B, 0 B) copied, 1.0 s, 0 B/s\n"
+    /// );
+    /// ```
+    fn write_prog_line(&self, w: &mut impl Write, rewrite: bool) -> std::io::Result<()> {
+        let btotal_metric = Byte::from_bytes(self.write_stat.bytes_total)
+            .get_appropriate_unit(false)
+            .format(0);
+        let btotal_bin = Byte::from_bytes(self.write_stat.bytes_total)
+            .get_appropriate_unit(true)
+            .format(0);
+        let safe_millis = std::cmp::max(1, self.duration.as_millis());
+        let transfer_rate = Byte::from_bytes(1000 * (self.write_stat.bytes_total / safe_millis))
+            .get_appropriate_unit(false)
+            .format(1);
+
+        let btotal = self.write_stat.bytes_total;
+        let duration = self.duration.as_secs_f64();
+        if rewrite {
+            write!(
+                w,
+                "\r{} bytes ({}, {}) copied, {:.1} s, {}/s",
+                btotal, btotal_metric, btotal_bin, duration, transfer_rate
+            )
+        } else {
+            writeln!(
+                w,
+                "{} bytes ({}, {}) copied, {:.1} s, {}/s",
+                btotal, btotal_metric, btotal_bin, duration, transfer_rate
+            )
+        }
+    }
+
+    /// Write all summary statistics.
+    ///
+    /// This is a convenience method that calls
+    /// [`ProgUpdate::write_io_lines`] and
+    /// [`ProgUpdate::write_prog_line`] in that order. The information
+    /// is written to `w`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// use std::io::Cursor;
+    /// use std::time::Duration;
+    /// use crate::progress::{ProgUpdate, ReadState, WriteStat};
+    ///
+    /// let prog_update = ProgUpdate {
+    ///     read_stat: Default::default(),
+    ///     write_stat: Default::default(),
+    ///     duration: Duration::new(1, 0), // one second
+    /// };
+    /// let mut cursor = Cursor::new(vec![]);
+    /// prog_update.write_transfer_stats(&mut cursor).unwrap();
+    /// let mut iter = cursor.get_ref().split(|v| *v == b'\n');
+    /// assert_eq!(iter.next().unwrap(), b"0+0 records in");
+    /// assert_eq!(iter.next().unwrap(), b"0+0 records out");
+    /// assert_eq!(
+    ///     iter.next().unwrap(),
+    ///     b"0 bytes (0 B, 0 B) copied, 1.0 s, 0 B/s"
+    /// );
+    /// assert_eq!(iter.next().unwrap(), b"");
+    /// assert!(iter.next().is_none());
+    /// ```
+    fn write_transfer_stats(&self, w: &mut impl Write) -> std::io::Result<()> {
+        self.write_io_lines(w)?;
+        let rewrite = false;
+        self.write_prog_line(w, rewrite)?;
+        Ok(())
+    }
+
+    /// Print number of complete and partial records read and written to stderr.
+    ///
+    /// See [`ProgUpdate::write_io_lines`] for more information.
+    pub(crate) fn print_io_lines(&self) {
+        let mut stderr = std::io::stderr();
+        self.write_io_lines(&mut stderr).unwrap();
+    }
+
+    /// Re-print the number of bytes written, duration, and throughput.
+    ///
+    /// See [`ProgUpdate::write_prog_line`] for more information.
+    pub(crate) fn reprint_prog_line(&self) {
+        let mut stderr = std::io::stderr();
+        let rewrite = true;
+        self.write_prog_line(&mut stderr, rewrite).unwrap();
+    }
+
+    /// Write all summary statistics.
+    ///
+    /// See [`ProgUpdate::write_transfer_stats`] for more information.
+    pub(crate) fn print_transfer_stats(&self) {
+        let mut stderr = std::io::stderr();
+        self.write_transfer_stats(&mut stderr).unwrap();
+    }
+}
+
+/// Read statistics.
+///
+/// This contains information about the number of blocks read from the
+/// input file. A block is sometimes referred to as a "record".
+#[derive(Clone, Copy, Default)]
+pub(crate) struct ReadStat {
+    /// The number of complete blocks that have been read.
+    pub(crate) reads_complete: u64,
+
+    /// The number of partial blocks that have been read.
+    ///
+    /// A partial block read can happen if, for example, there are
+    /// fewer bytes in the input file than the specified input block
+    /// size.
+    pub(crate) reads_partial: u64,
+
+    /// The number of truncated records.
+    ///
+    /// A truncated record can only occur in `conv=block` mode.
+    pub(crate) records_truncated: u32,
+}
+
+impl ReadStat {
+    /// Create a new instance.
+    #[allow(dead_code)]
+    fn new(complete: u64, partial: u64, truncated: u32) -> Self {
+        Self {
+            reads_complete: complete,
+            reads_partial: partial,
+            records_truncated: truncated,
+        }
+    }
+
+    /// Whether this counter has zero complete reads and zero partial reads.
+    pub(crate) fn is_empty(&self) -> bool {
+        self.reads_complete == 0 && self.reads_partial == 0
+    }
+
+    /// Write the counts in the format required by `dd`.
+    ///
+    /// # Errors
+    ///
+    /// If there is a problem writing to `w`.
+    fn report(&self, w: &mut impl Write) -> std::io::Result<()> {
+        writeln!(
+            w,
+            "{}+{} records in",
+            self.reads_complete, self.reads_partial
+        )?;
+        Ok(())
+    }
+}
+
+impl std::ops::AddAssign for ReadStat {
+    fn add_assign(&mut self, other: Self) {
+        *self = Self {
+            reads_complete: self.reads_complete + other.reads_complete,
+            reads_partial: self.reads_partial + other.reads_partial,
+            records_truncated: self.records_truncated + other.records_truncated,
+        }
+    }
+}
+
+/// Write statistics.
+///
+/// This contains information about the number of blocks written to
+/// the output file and the total number of bytes written.
+#[derive(Clone, Copy, Default)]
+pub(crate) struct WriteStat {
+    /// The number of complete blocks that have been written.
+    pub(crate) writes_complete: u64,
+
+    /// The number of partial blocks that have been written.
+    ///
+    /// A partial block write can happen if, for example, there are
+    /// fewer bytes in the input file than the specified output block
+    /// size.
+    pub(crate) writes_partial: u64,
+
+    /// The total number of bytes written.
+    pub(crate) bytes_total: u128,
+}
+
+impl WriteStat {
+    /// Create a new instance.
+    #[allow(dead_code)]
+    fn new(complete: u64, partial: u64, bytes_total: u128) -> Self {
+        Self {
+            writes_complete: complete,
+            writes_partial: partial,
+            bytes_total,
+        }
+    }
+
+    /// Write the counts in the format required by `dd`.
+    ///
+    /// # Errors
+    ///
+    /// If there is a problem writing to `w`.
+    fn report(&self, w: &mut impl Write) -> std::io::Result<()> {
+        writeln!(
+            w,
+            "{}+{} records out",
+            self.writes_complete, self.writes_partial
+        )
+    }
+}
+
+impl std::ops::AddAssign for WriteStat {
+    fn add_assign(&mut 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`
+/// command-line argument.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub(crate) enum StatusLevel {
+    /// Report number of blocks read and written, throughput, and volume.
+    ///
+    /// This corresponds to `status=progress`.
+    Progress,
+
+    /// Report number of blocks read and written, but no throughput and volume.
+    ///
+    /// This corresponds to `status=noxfer`.
+    Noxfer,
+
+    /// Print no status information.
+    None,
+}
+
+/// Return a closure that can be used in its own thread to print progress info.
+///
+/// This function returns a closure that receives [`ProgUpdate`]
+/// instances sent through `rx`. When a [`ProgUpdate`] instance is
+/// received, the transfer statistics are re-printed to stderr.
+#[cfg(not(target_os = "linux"))]
+pub(crate) fn gen_prog_updater(
+    rx: mpsc::Receiver<ProgUpdate>,
+    print_level: Option<StatusLevel>,
+) -> impl Fn() {
+    move || {
+        while let Ok(update) = rx.recv() {
+            if Some(StatusLevel::Progress) == print_level {
+                update.reprint_prog_line();
+            }
+        }
+    }
+}
+
+/// Return a closure that can be used in its own thread to print progress info.
+///
+/// This function returns a closure that receives [`ProgUpdate`]
+/// instances sent through `rx`. When a [`ProgUpdate`] instance is
+/// received, the transfer statistics are re-printed to stderr.
+///
+/// The closure also registers a signal handler for `SIGUSR1`. When
+/// the `SIGUSR1` signal is sent to this process, the transfer
+/// statistics are printed to stderr.
+#[cfg(target_os = "linux")]
+pub(crate) fn gen_prog_updater(
+    rx: mpsc::Receiver<ProgUpdate>,
+    print_level: Option<StatusLevel>,
+) -> impl Fn() {
+    // TODO: SIGINFO: Trigger progress line reprint. BSD-style Linux only.
+    const SIGUSR1_USIZE: usize = signal::SIGUSR1 as usize;
+    fn posixly_correct() -> bool {
+        env::var("POSIXLY_CORRECT").is_ok()
+    }
+    fn register_linux_signal_handler(sigval: Arc<AtomicUsize>) -> Result<(), Box<dyn Error>> {
+        if !posixly_correct() {
+            signal_hook::flag::register_usize(signal::SIGUSR1, sigval, SIGUSR1_USIZE)?;
+        }
+
+        Ok(())
+    }
+    // --------------------------------------------------------------
+    move || {
+        let sigval = Arc::new(AtomicUsize::new(0));
+
+        register_linux_signal_handler(sigval.clone()).unwrap_or_else(|e| {
+            if Some(StatusLevel::None) != print_level {
+                eprintln!(
+                    "Internal dd Warning: Unable to register signal handler \n\t{}",
+                    e
+                );
+            }
+        });
+
+        let mut progress_as_secs = 0;
+        while let Ok(update) = rx.recv() {
+            // (Re)print status line if progress is requested.
+            if Some(StatusLevel::Progress) == print_level
+                && update.duration.as_secs() >= progress_as_secs
+            {
+                update.reprint_prog_line();
+                progress_as_secs = update.duration.as_secs() + 1;
+            }
+            // Handle signals
+            if let SIGUSR1_USIZE = sigval.load(Ordering::Relaxed) {
+                update.print_transfer_stats();
+            };
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::io::Cursor;
+    use std::time::Duration;
+
+    use super::{ProgUpdate, ReadStat, WriteStat};
+
+    #[test]
+    fn test_read_stat_report() {
+        let read_stat = ReadStat::new(1, 2, 3);
+        let mut cursor = Cursor::new(vec![]);
+        read_stat.report(&mut cursor).unwrap();
+        assert_eq!(cursor.get_ref(), b"1+2 records in\n");
+    }
+
+    #[test]
+    fn test_write_stat_report() {
+        let write_stat = WriteStat::new(1, 2, 3);
+        let mut cursor = Cursor::new(vec![]);
+        write_stat.report(&mut cursor).unwrap();
+        assert_eq!(cursor.get_ref(), b"1+2 records out\n");
+    }
+
+    #[test]
+    fn test_prog_update_write_io_lines() {
+        let read_stat = ReadStat::new(1, 2, 3);
+        let write_stat = WriteStat::new(4, 5, 6);
+        let duration = Duration::new(789, 0);
+        let prog_update = ProgUpdate {
+            read_stat,
+            write_stat,
+            duration,
+        };
+
+        let mut cursor = Cursor::new(vec![]);
+        prog_update.write_io_lines(&mut cursor).unwrap();
+        assert_eq!(
+            cursor.get_ref(),
+            b"1+2 records in\n4+5 records out\n3 truncated records\n"
+        );
+    }
+
+    #[test]
+    fn test_prog_update_write_prog_line() {
+        let prog_update = ProgUpdate {
+            read_stat: Default::default(),
+            write_stat: Default::default(),
+            duration: Duration::new(1, 0), // one second
+        };
+
+        let mut cursor = Cursor::new(vec![]);
+        let rewrite = false;
+        prog_update.write_prog_line(&mut cursor, rewrite).unwrap();
+        // TODO The expected output string below is what our code
+        // produces today, but it does not match GNU dd:
+        //
+        //     $ : | dd
+        //     0 bytes copied, 7.9151e-05 s, 0.0 kB/s
+        //
+        assert_eq!(
+            cursor.get_ref(),
+            b"0 bytes (0 B, 0 B) copied, 1.0 s, 0 B/s\n"
+        );
+    }
+
+    #[test]
+    fn write_transfer_stats() {
+        let prog_update = ProgUpdate {
+            read_stat: Default::default(),
+            write_stat: Default::default(),
+            duration: Duration::new(1, 0), // one second
+        };
+        let mut cursor = Cursor::new(vec![]);
+        prog_update.write_transfer_stats(&mut cursor).unwrap();
+        let mut iter = cursor.get_ref().split(|v| *v == b'\n');
+        assert_eq!(iter.next().unwrap(), b"0+0 records in");
+        assert_eq!(iter.next().unwrap(), b"0+0 records out");
+        assert_eq!(
+            iter.next().unwrap(),
+            b"0 bytes (0 B, 0 B) copied, 1.0 s, 0 B/s"
+        );
+        assert_eq!(iter.next().unwrap(), b"");
+        assert!(iter.next().is_none());
+    }
+}
diff --git a/src/uu/dd/test-resources/FAILED-random-5828891cb1230748e146f34223bbd3b5.test b/src/uu/dd/test-resources/FAILED-random-5828891cb1230748e146f34223bbd3b5.test
new file mode 100644
index 000000000..6e997411c
Binary files /dev/null and b/src/uu/dd/test-resources/FAILED-random-5828891cb1230748e146f34223bbd3b5.test differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-atoe-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-atoe-seq-byte-values.spec
deleted file mode 100644
index 8701c67fd..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-atoe-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-atoibm-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-atoibm-seq-byte-values.spec
deleted file mode 100644
index 3835d57cf..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-atoibm-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-ebcdic-ltou-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-ebcdic-ltou-seq-byte-values.spec
deleted file mode 100644
index ed0686639..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-ebcdic-ltou-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-ebcdic-utol-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-ebcdic-utol-seq-byte-values.spec
deleted file mode 100644
index 13c82e5e3..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-ebcdic-utol-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-etoa-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-etoa-seq-byte-values.spec
deleted file mode 100644
index 433b1f600..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-etoa-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-ibm-ltou-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-ibm-ltou-seq-byte-values.spec
deleted file mode 100644
index d425e7d01..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-ibm-ltou-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-ibm-utol-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-ibm-utol-seq-byte-values.spec
deleted file mode 100644
index 1dcaccbcd..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-ibm-utol-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-ltou-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-ltou-seq-byte-values.spec
deleted file mode 100644
index 5aacec0cd..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-ltou-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/gnudd-conv-utol-seq-byte-values.spec b/src/uu/dd/test-resources/gnudd-conv-utol-seq-byte-values.spec
deleted file mode 100644
index d205368d5..000000000
Binary files a/src/uu/dd/test-resources/gnudd-conv-utol-seq-byte-values.spec and /dev/null differ
diff --git a/src/uu/dd/test-resources/seq-byte-values.test b/src/uu/dd/test-resources/seq-byte-values.test
deleted file mode 100644
index c86626638..000000000
Binary files a/src/uu/dd/test-resources/seq-byte-values.test and /dev/null differ
diff --git a/src/uu/df/Cargo.toml b/src/uu/df/Cargo.toml
index 9486640d0..0490621ca 100644
--- a/src/uu/df/Cargo.toml
+++ b/src/uu/df/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_df"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "df ~ (uutils) display file system information"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/df"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/df"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/df.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 number_prefix = "0.4"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["libc", "fsext"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["libc", "fsext"] }
 
 [[bin]]
 name = "df"
diff --git a/src/uu/df/LICENSE b/src/uu/df/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/df/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/df/src/blocks.rs b/src/uu/df/src/blocks.rs
new file mode 100644
index 000000000..0943c9447
--- /dev/null
+++ b/src/uu/df/src/blocks.rs
@@ -0,0 +1,197 @@
+//  * 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.
+//! Types for representing and displaying block sizes.
+use crate::{OPT_BLOCKSIZE, OPT_HUMAN_READABLE_BINARY, OPT_HUMAN_READABLE_DECIMAL};
+use clap::ArgMatches;
+use std::fmt;
+use std::num::ParseIntError;
+
+/// The first ten powers of 1024.
+const IEC_BASES: [u128; 10] = [
+    1,
+    1_024,
+    1_048_576,
+    1_073_741_824,
+    1_099_511_627_776,
+    1_125_899_906_842_624,
+    1_152_921_504_606_846_976,
+    1_180_591_620_717_411_303_424,
+    1_208_925_819_614_629_174_706_176,
+    1_237_940_039_285_380_274_899_124_224,
+];
+
+/// Suffixes for the first nine multi-byte unit suffixes.
+const SUFFIXES: [char; 9] = ['B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+
+/// Convert a multiple of 1024 into a string like "12K" or "34M".
+///
+/// # Examples
+///
+/// Powers of 1024 become "1K", "1M", "1G", etc.
+///
+/// ```rust,ignore
+/// assert_eq!(to_magnitude_and_suffix_1024(1024).unwrap(), "1K");
+/// assert_eq!(to_magnitude_and_suffix_1024(1024 * 1024).unwrap(), "1M");
+/// assert_eq!(to_magnitude_and_suffix_1024(1024 * 1024 * 1024).unwrap(), "1G");
+/// ```
+///
+/// Multiples of those powers affect the magnitude part of the
+/// returned string:
+///
+/// ```rust,ignore
+/// assert_eq!(to_magnitude_and_suffix_1024(123 * 1024).unwrap(), "123K");
+/// assert_eq!(to_magnitude_and_suffix_1024(456 * 1024 * 1024).unwrap(), "456M");
+/// assert_eq!(to_magnitude_and_suffix_1024(789 * 1024 * 1024 * 1024).unwrap(), "789G");
+/// ```
+fn to_magnitude_and_suffix_1024(n: u128) -> Result<String, ()> {
+    // Find the smallest power of 1024 that is larger than `n`. That
+    // number indicates which units and suffix to use.
+    for i in 0..IEC_BASES.len() - 1 {
+        if n < IEC_BASES[i + 1] {
+            return Ok(format!("{}{}", n / IEC_BASES[i], SUFFIXES[i]));
+        }
+    }
+    Err(())
+}
+
+/// Convert a number into a magnitude and a multi-byte unit suffix.
+///
+/// # Errors
+///
+/// If the number is too large to represent.
+fn to_magnitude_and_suffix(n: u128) -> Result<String, ()> {
+    if n % 1024 == 0 {
+        to_magnitude_and_suffix_1024(n)
+    } else {
+        // TODO Implement this, probably using code from `numfmt`.
+        Ok("1kB".into())
+    }
+}
+
+/// A block size to use in condensing the display of a large number of bytes.
+///
+/// The [`BlockSize::Bytes`] variant represents a static block
+/// size. The [`BlockSize::HumanReadableDecimal`] and
+/// [`BlockSize::HumanReadableBinary`] variants represent dynamic
+/// block sizes: as the number of bytes increases, the divisor
+/// increases as well (for example, from 1 to 1,000 to 1,000,000 and
+/// so on in the case of [`BlockSize::HumanReadableDecimal`]).
+///
+/// The default variant is `Bytes(1024)`.
+pub(crate) enum BlockSize {
+    /// A fixed number of bytes.
+    ///
+    /// The number must be positive.
+    Bytes(u64),
+
+    /// Use the largest divisor corresponding to a unit, like B, K, M, G, etc.
+    ///
+    /// This variant represents powers of 1,000. Contrast with
+    /// [`BlockSize::HumanReadableBinary`], which represents powers of
+    /// 1,024.
+    HumanReadableDecimal,
+
+    /// Use the largest divisor corresponding to a unit, like B, K, M, G, etc.
+    ///
+    /// This variant represents powers of 1,024. Contrast with
+    /// [`BlockSize::HumanReadableDecimal`], which represents powers
+    /// of 1,000.
+    HumanReadableBinary,
+}
+
+impl Default for BlockSize {
+    fn default() -> Self {
+        Self::Bytes(1024)
+    }
+}
+
+pub(crate) fn block_size_from_matches(matches: &ArgMatches) -> Result<BlockSize, ParseIntError> {
+    if matches.is_present(OPT_HUMAN_READABLE_BINARY) {
+        Ok(BlockSize::HumanReadableBinary)
+    } else if matches.is_present(OPT_HUMAN_READABLE_DECIMAL) {
+        Ok(BlockSize::HumanReadableDecimal)
+    } else if matches.is_present(OPT_BLOCKSIZE) {
+        let s = matches.value_of(OPT_BLOCKSIZE).unwrap();
+        Ok(BlockSize::Bytes(s.parse()?))
+    } else {
+        Ok(Default::default())
+    }
+}
+
+impl fmt::Display for BlockSize {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::HumanReadableBinary => write!(f, "Size"),
+            Self::HumanReadableDecimal => write!(f, "Size"),
+            Self::Bytes(n) => match to_magnitude_and_suffix(*n as u128) {
+                Ok(s) => write!(f, "{}-blocks", s),
+                Err(_) => Err(fmt::Error),
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::blocks::{to_magnitude_and_suffix, BlockSize};
+
+    #[test]
+    fn test_to_magnitude_and_suffix_powers_of_1024() {
+        assert_eq!(to_magnitude_and_suffix(1024).unwrap(), "1K");
+        assert_eq!(to_magnitude_and_suffix(2048).unwrap(), "2K");
+        assert_eq!(to_magnitude_and_suffix(4096).unwrap(), "4K");
+        assert_eq!(to_magnitude_and_suffix(1024 * 1024).unwrap(), "1M");
+        assert_eq!(to_magnitude_and_suffix(2 * 1024 * 1024).unwrap(), "2M");
+        assert_eq!(to_magnitude_and_suffix(1024 * 1024 * 1024).unwrap(), "1G");
+        assert_eq!(
+            to_magnitude_and_suffix(34 * 1024 * 1024 * 1024).unwrap(),
+            "34G"
+        );
+    }
+
+    // TODO We have not yet implemented this behavior, but when we do,
+    // uncomment this test.
+
+    // #[test]
+    // fn test_to_magnitude_and_suffix_not_powers_of_1024() {
+    //     assert_eq!(to_magnitude_and_suffix(1).unwrap(), "1B");
+    //     assert_eq!(to_magnitude_and_suffix(999).unwrap(), "999B");
+
+    //     assert_eq!(to_magnitude_and_suffix(1000).unwrap(), "1kB");
+    //     assert_eq!(to_magnitude_and_suffix(1001).unwrap(), "1.1kB");
+    //     assert_eq!(to_magnitude_and_suffix(1023).unwrap(), "1.1kB");
+    //     assert_eq!(to_magnitude_and_suffix(1025).unwrap(), "1.1kB");
+    //     assert_eq!(to_magnitude_and_suffix(999_000).unwrap(), "999kB");
+
+    //     assert_eq!(to_magnitude_and_suffix(999_001).unwrap(), "1MB");
+    //     assert_eq!(to_magnitude_and_suffix(999_999).unwrap(), "1MB");
+    //     assert_eq!(to_magnitude_and_suffix(1_000_000).unwrap(), "1MB");
+    //     assert_eq!(to_magnitude_and_suffix(1_000_001).unwrap(), "1.1MB");
+    //     assert_eq!(to_magnitude_and_suffix(1_100_000).unwrap(), "1.1MB");
+    //     assert_eq!(to_magnitude_and_suffix(1_100_001).unwrap(), "1.2MB");
+    //     assert_eq!(to_magnitude_and_suffix(1_900_000).unwrap(), "1.9MB");
+    //     assert_eq!(to_magnitude_and_suffix(1_900_001).unwrap(), "2MB");
+    //     assert_eq!(to_magnitude_and_suffix(9_900_000).unwrap(), "9.9MB");
+    //     assert_eq!(to_magnitude_and_suffix(9_900_001).unwrap(), "10MB");
+    //     assert_eq!(to_magnitude_and_suffix(999_000_000).unwrap(), "999MB");
+
+    //     assert_eq!(to_magnitude_and_suffix(999_000_001).unwrap(), "1GB");
+    //     assert_eq!(to_magnitude_and_suffix(1_000_000_000).unwrap(), "1GB");
+    //     // etc.
+    // }
+
+    #[test]
+    fn test_block_size_display() {
+        assert_eq!(format!("{}", BlockSize::HumanReadableBinary), "Size");
+        assert_eq!(format!("{}", BlockSize::HumanReadableDecimal), "Size");
+        assert_eq!(format!("{}", BlockSize::Bytes(1024)), "1K-blocks");
+        assert_eq!(format!("{}", BlockSize::Bytes(2 * 1024)), "2K-blocks");
+        assert_eq!(
+            format!("{}", BlockSize::Bytes(3 * 1024 * 1024)),
+            "3M-blocks"
+        );
+    }
+}
diff --git a/src/uu/df/src/columns.rs b/src/uu/df/src/columns.rs
new file mode 100644
index 000000000..91c52ed2e
--- /dev/null
+++ b/src/uu/df/src/columns.rs
@@ -0,0 +1,186 @@
+//  * 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 itotal iused iavail ipcent pcent squashfs
+use crate::{OPT_INODES, OPT_OUTPUT, OPT_PRINT_TYPE};
+use clap::ArgMatches;
+
+/// The columns in the output table produced by `df`.
+///
+/// The [`Row`] struct has a field corresponding to each of the
+/// variants of this enumeration.
+///
+/// [`Row`]: crate::table::Row
+#[derive(PartialEq, Copy, Clone)]
+pub(crate) enum Column {
+    /// The source of the mount point, usually a device.
+    Source,
+
+    /// Total number of blocks.
+    Size,
+
+    /// Number of used blocks.
+    Used,
+
+    /// Number of available blocks.
+    Avail,
+
+    /// Percentage of blocks used out of total number of blocks.
+    Pcent,
+
+    /// The mount point.
+    Target,
+
+    /// Total number of inodes.
+    Itotal,
+
+    /// Number of used inodes.
+    Iused,
+
+    /// Number of available inodes.
+    Iavail,
+
+    /// Percentage of inodes used out of total number of inodes.
+    Ipcent,
+
+    /// The filename given as a command-line argument.
+    File,
+
+    /// The filesystem type, like "ext4" or "squashfs".
+    Fstype,
+
+    /// Percentage of bytes available to non-privileged processes.
+    #[cfg(target_os = "macos")]
+    Capacity,
+}
+
+/// An error while defining which columns to display in the output table.
+#[derive(Debug)]
+pub(crate) enum ColumnError {
+    /// If a column appears more than once in the `--output` argument.
+    MultipleColumns(String),
+}
+
+impl Column {
+    /// Convert from command-line arguments to sequence of columns.
+    ///
+    /// The set of columns that will appear in the output table can be
+    /// specified by command-line arguments. This function converts
+    /// those arguments to a [`Vec`] of [`Column`] variants.
+    ///
+    /// # Errors
+    ///
+    /// This function returns an error if a column is specified more
+    /// than once in the command-line argument.
+    pub(crate) fn from_matches(matches: &ArgMatches) -> Result<Vec<Self>, ColumnError> {
+        match (
+            matches.is_present(OPT_PRINT_TYPE),
+            matches.is_present(OPT_INODES),
+            matches.occurrences_of(OPT_OUTPUT) > 0,
+        ) {
+            (false, false, false) => Ok(vec![
+                Self::Source,
+                Self::Size,
+                Self::Used,
+                Self::Avail,
+                #[cfg(target_os = "macos")]
+                Self::Capacity,
+                Self::Pcent,
+                Self::Target,
+            ]),
+            (false, false, true) => {
+                // Unwrapping should not panic because in this arm of
+                // the `match` statement, we know that `OPT_OUTPUT`
+                // is non-empty.
+                let names = matches.values_of(OPT_OUTPUT).unwrap();
+                let mut seen: Vec<&str> = vec![];
+                let mut columns = vec![];
+                for name in names {
+                    if seen.contains(&name) {
+                        return Err(ColumnError::MultipleColumns(name.to_string()));
+                    }
+                    seen.push(name);
+                    // Unwrapping here should not panic because the
+                    // command-line argument parsing library should be
+                    // responsible for ensuring each comma-separated
+                    // string is a valid column label.
+                    let column = Self::parse(name).unwrap();
+                    columns.push(column);
+                }
+                Ok(columns)
+            }
+            (false, true, false) => Ok(vec![
+                Self::Source,
+                Self::Itotal,
+                Self::Iused,
+                Self::Iavail,
+                Self::Ipcent,
+                Self::Target,
+            ]),
+            (true, false, false) => Ok(vec![
+                Self::Source,
+                Self::Fstype,
+                Self::Size,
+                Self::Used,
+                Self::Avail,
+                #[cfg(target_os = "macos")]
+                Self::Capacity,
+                Self::Pcent,
+                Self::Target,
+            ]),
+            (true, true, false) => Ok(vec![
+                Self::Source,
+                Self::Fstype,
+                Self::Itotal,
+                Self::Iused,
+                Self::Iavail,
+                Self::Ipcent,
+                Self::Target,
+            ]),
+            // The command-line arguments -T and -i are each mutually
+            // exclusive with --output, so the command-line argument
+            // parser should reject those combinations before we get
+            // to this point in the code.
+            _ => unreachable!(),
+        }
+    }
+
+    /// Convert a column name to the corresponding enumeration variant.
+    ///
+    /// There are twelve valid column names, one for each variant:
+    ///
+    /// - "source"
+    /// - "fstype"
+    /// - "itotal"
+    /// - "iused"
+    /// - "iavail"
+    /// - "ipcent"
+    /// - "size"
+    /// - "used"
+    /// - "avail"
+    /// - "pcent"
+    /// - "file"
+    /// - "target"
+    ///
+    /// # Errors
+    ///
+    /// If the string `s` is not one of the valid column names.
+    fn parse(s: &str) -> Result<Self, ()> {
+        match s {
+            "source" => Ok(Self::Source),
+            "fstype" => Ok(Self::Fstype),
+            "itotal" => Ok(Self::Itotal),
+            "iused" => Ok(Self::Iused),
+            "iavail" => Ok(Self::Iavail),
+            "ipcent" => Ok(Self::Ipcent),
+            "size" => Ok(Self::Size),
+            "used" => Ok(Self::Used),
+            "avail" => Ok(Self::Avail),
+            "pcent" => Ok(Self::Pcent),
+            "file" => Ok(Self::File),
+            "target" => Ok(Self::Target),
+            _ => Err(()),
+        }
+    }
+}
diff --git a/src/uu/df/src/df.rs b/src/uu/df/src/df.rs
index 2f703542c..d125e73d0 100644
--- a/src/uu/df/src/df.rs
+++ b/src/uu/df/src/df.rs
@@ -5,39 +5,38 @@
 //
 // For the full copyright and license information, please view the LICENSE file
 // that was distributed with this source code.
+// spell-checker:ignore itotal iused iavail ipcent pcent tmpfs squashfs lofs
+mod blocks;
+mod columns;
+mod filesystem;
+mod table;
 
-use uucore::error::UError;
-use uucore::error::UResult;
-#[cfg(unix)]
-use uucore::fsext::statfs_fn;
-use uucore::fsext::{read_fs_list, FsUsage, MountInfo};
+use uucore::display::Quotable;
+use uucore::error::{UError, UResult};
+use uucore::format_usage;
+use uucore::fsext::{read_fs_list, MountInfo};
 
-use clap::{crate_version, App, Arg};
-
-use number_prefix::NumberPrefix;
-use std::cell::Cell;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use clap::{crate_version, Arg, ArgMatches, Command};
 
 use std::error::Error;
-#[cfg(unix)]
-use std::ffi::CString;
-use std::fmt::Display;
-#[cfg(unix)]
-use std::mem;
-
-#[cfg(windows)]
+use std::fmt;
 use std::path::Path;
 
+use crate::blocks::{block_size_from_matches, BlockSize};
+use crate::columns::{Column, ColumnError};
+use crate::filesystem::Filesystem;
+use crate::table::{DisplayRow, Header, Row};
+
 static ABOUT: &str = "Show information about the file system on which each FILE resides,\n\
                       or all file systems by default.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
+static OPT_HELP: &str = "help";
 static OPT_ALL: &str = "all";
 static OPT_BLOCKSIZE: &str = "blocksize";
-static OPT_DIRECT: &str = "direct";
 static OPT_TOTAL: &str = "total";
-static OPT_HUMAN_READABLE: &str = "human-readable";
-static OPT_HUMAN_READABLE_2: &str = "human-readable-2";
+static OPT_HUMAN_READABLE_BINARY: &str = "human-readable-binary";
+static OPT_HUMAN_READABLE_DECIMAL: &str = "human-readable-decimal";
 static OPT_INODES: &str = "inodes";
 static OPT_KILO: &str = "kilo";
 static OPT_LOCAL: &str = "local";
@@ -49,244 +48,267 @@ static OPT_SYNC: &str = "sync";
 static OPT_TYPE: &str = "type";
 static OPT_PRINT_TYPE: &str = "print-type";
 static OPT_EXCLUDE_TYPE: &str = "exclude-type";
+static OUTPUT_FIELD_LIST: [&str; 12] = [
+    "source", "fstype", "itotal", "iused", "iavail", "ipcent", "size", "used", "avail", "pcent",
+    "file", "target",
+];
 
-/// Store names of file systems as a selector.
-/// Note: `exclude` takes priority over `include`.
-struct FsSelector {
-    include: HashSet<String>,
-    exclude: HashSet<String>,
-}
-
+/// Parameters that control the behavior of `df`.
+///
+/// Most of these parameters control which rows and which columns are
+/// displayed. The `block_size` determines the units to use when
+/// displaying numbers of bytes or inodes.
 struct Options {
     show_local_fs: bool,
     show_all_fs: bool,
     show_listed_fs: bool,
-    show_fs_type: bool,
-    show_inode_instead: bool,
-    // block_size: usize,
-    human_readable_base: i64,
-    fs_selector: FsSelector,
+    block_size: BlockSize,
+
+    /// Optional list of filesystem types to include in the output table.
+    ///
+    /// If this is not `None`, only filesystems that match one of
+    /// these types will be listed.
+    include: Option<Vec<String>>,
+
+    /// Optional list of filesystem types to exclude from the output table.
+    ///
+    /// If this is not `None`, filesystems that match one of these
+    /// types will *not* be listed.
+    exclude: Option<Vec<String>>,
+
+    /// Whether to show a final row comprising the totals for each column.
+    show_total: bool,
+
+    /// Sequence of columns to display in the output table.
+    columns: Vec<Column>,
 }
 
-#[derive(Debug, Clone)]
-struct Filesystem {
-    mount_info: MountInfo,
-    usage: FsUsage,
-}
-
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
-
-impl FsSelector {
-    fn new() -> FsSelector {
-        FsSelector {
-            include: HashSet::new(),
-            exclude: HashSet::new(),
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            show_local_fs: Default::default(),
+            show_all_fs: Default::default(),
+            show_listed_fs: Default::default(),
+            block_size: Default::default(),
+            include: Default::default(),
+            exclude: Default::default(),
+            show_total: Default::default(),
+            columns: vec![
+                Column::Source,
+                Column::Size,
+                Column::Used,
+                Column::Avail,
+                Column::Pcent,
+                Column::Target,
+            ],
         }
     }
+}
 
-    #[inline(always)]
-    fn include(&mut self, fs_type: String) {
-        self.include.insert(fs_type);
-    }
+#[derive(Debug)]
+enum OptionsError {
+    InvalidBlockSize,
 
-    #[inline(always)]
-    fn exclude(&mut self, fs_type: String) {
-        self.exclude.insert(fs_type);
-    }
+    /// An error getting the columns to display in the output table.
+    ColumnError(ColumnError),
+}
 
-    fn should_select(&self, fs_type: &str) -> bool {
-        if self.exclude.contains(fs_type) {
-            return false;
+impl fmt::Display for OptionsError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            // TODO This should include the raw string provided as the argument.
+            //
+            // TODO This needs to vary based on whether `--block-size`
+            // or `-B` were provided.
+            Self::InvalidBlockSize => write!(f, "invalid --block-size argument"),
+            Self::ColumnError(ColumnError::MultipleColumns(s)) => write!(
+                f,
+                "option --output: field {} used more than once",
+                s.quote()
+            ),
         }
-        self.include.is_empty() || self.include.contains(fs_type)
     }
 }
 
 impl Options {
-    fn new() -> Options {
-        Options {
-            show_local_fs: false,
-            show_all_fs: false,
+    /// Convert command-line arguments into [`Options`].
+    fn from(matches: &ArgMatches) -> Result<Self, OptionsError> {
+        Ok(Self {
+            show_local_fs: matches.is_present(OPT_LOCAL),
+            show_all_fs: matches.is_present(OPT_ALL),
             show_listed_fs: false,
-            show_fs_type: false,
-            show_inode_instead: false,
-            // block_size: match env::var("BLOCKSIZE") {
-            //     Ok(size) => size.parse().unwrap(),
-            //     Err(_) => 512,
-            // },
-            human_readable_base: -1,
-            fs_selector: FsSelector::new(),
-        }
-    }
-}
-
-impl Filesystem {
-    // TODO: resolve uuid in `mount_info.dev_name` if exists
-    fn new(mount_info: MountInfo) -> Option<Filesystem> {
-        let _stat_path = if !mount_info.mount_dir.is_empty() {
-            mount_info.mount_dir.clone()
-        } else {
-            #[cfg(unix)]
-            {
-                mount_info.dev_name.clone()
-            }
-            #[cfg(windows)]
-            {
-                // On windows, we expect the volume id
-                mount_info.dev_id.clone()
-            }
-        };
-        #[cfg(unix)]
-        unsafe {
-            let path = CString::new(_stat_path).unwrap();
-            let mut statvfs = mem::zeroed();
-            if statfs_fn(path.as_ptr(), &mut statvfs) < 0 {
-                None
-            } else {
-                Some(Filesystem {
-                    mount_info,
-                    usage: FsUsage::new(statvfs),
-                })
-            }
-        }
-        #[cfg(windows)]
-        Some(Filesystem {
-            mount_info,
-            usage: FsUsage::new(Path::new(&_stat_path)),
+            block_size: block_size_from_matches(matches)
+                .map_err(|_| OptionsError::InvalidBlockSize)?,
+            include: matches.values_of_lossy(OPT_TYPE),
+            exclude: matches.values_of_lossy(OPT_EXCLUDE_TYPE),
+            show_total: matches.is_present(OPT_TOTAL),
+            columns: Column::from_matches(matches).map_err(OptionsError::ColumnError)?,
         })
     }
 }
 
-fn filter_mount_list(vmi: Vec<MountInfo>, paths: &[String], opt: &Options) -> Vec<MountInfo> {
-    vmi.into_iter()
-        .filter_map(|mi| {
-            if (mi.remote && opt.show_local_fs)
-                || (mi.dummy && !opt.show_all_fs && !opt.show_listed_fs)
-                || !opt.fs_selector.should_select(&mi.fs_type)
-            {
-                None
-            } else {
-                if paths.is_empty() {
-                    // No path specified
-                    return Some((mi.dev_id.clone(), mi));
-                }
-                if paths.contains(&mi.mount_dir) {
-                    // One or more paths have been provided
-                    Some((mi.dev_id.clone(), mi))
-                } else {
-                    // Not a path we want to see
-                    None
-                }
-            }
-        })
-        .fold(
-            HashMap::<String, Cell<MountInfo>>::new(),
-            |mut acc, (id, mi)| {
-                #[allow(clippy::map_entry)]
-                {
-                    if acc.contains_key(&id) {
-                        let seen = acc[&id].replace(mi.clone());
-                        let target_nearer_root = seen.mount_dir.len() > mi.mount_dir.len();
-                        // With bind mounts, prefer items nearer the root of the source
-                        let source_below_root = !seen.mount_root.is_empty()
-                            && !mi.mount_root.is_empty()
-                            && seen.mount_root.len() < mi.mount_root.len();
-                        // let "real" devices with '/' in the name win.
-                        if (!mi.dev_name.starts_with('/') || seen.dev_name.starts_with('/'))
-                            // let points towards the root of the device win.
-                            && (!target_nearer_root || source_below_root)
-                            // let an entry over-mounted on a new device win...
-                            && (seen.dev_name == mi.dev_name
-                            /* ... but only when matching an existing mnt point,
-                            to avoid problematic replacement when given
-                            inaccurate mount lists, seen with some chroot
-                            environments for example.  */
-                            || seen.mount_dir != mi.mount_dir)
-                        {
-                            acc[&id].replace(seen);
-                        }
-                    } else {
-                        acc.insert(id, Cell::new(mi));
-                    }
-                    acc
-                }
-            },
-        )
+/// Whether to display the mount info given the inclusion settings.
+fn is_included(mi: &MountInfo, opt: &Options) -> bool {
+    // Don't show remote filesystems if `--local` has been given.
+    if mi.remote && opt.show_local_fs {
+        return false;
+    }
+
+    // Don't show pseudo filesystems unless `--all` has been given.
+    if mi.dummy && !opt.show_all_fs && !opt.show_listed_fs {
+        return false;
+    }
+
+    // Don't show filesystems if they have been explicitly excluded.
+    if let Some(ref excludes) = opt.exclude {
+        if excludes.contains(&mi.fs_type) {
+            return false;
+        }
+    }
+    if let Some(ref includes) = opt.include {
+        if !includes.contains(&mi.fs_type) {
+            return false;
+        }
+    }
+
+    true
+}
+
+/// Whether the mount info in `m2` should be prioritized over `m1`.
+///
+/// The "lt" in the function name is in analogy to the
+/// [`std::cmp::PartialOrd::lt`].
+fn mount_info_lt(m1: &MountInfo, m2: &MountInfo) -> bool {
+    // let "real" devices with '/' in the name win.
+    if m1.dev_name.starts_with('/') && !m2.dev_name.starts_with('/') {
+        return false;
+    }
+
+    let m1_nearer_root = m1.mount_dir.len() < m2.mount_dir.len();
+    // With bind mounts, prefer items nearer the root of the source
+    let m2_below_root = !m1.mount_root.is_empty()
+        && !m2.mount_root.is_empty()
+        && m1.mount_root.len() > m2.mount_root.len();
+    // let points towards the root of the device win.
+    if m1_nearer_root && !m2_below_root {
+        return false;
+    }
+
+    // let an entry over-mounted on a new device win, but only when
+    // matching an existing mnt point, to avoid problematic
+    // replacement when given inaccurate mount lists, seen with some
+    // chroot environments for example.
+    if m1.dev_name != m2.dev_name && m1.mount_dir == m2.mount_dir {
+        return false;
+    }
+
+    true
+}
+
+/// Whether to prioritize given mount info over all others on the same device.
+///
+/// This function decides whether the mount info `mi` is better than
+/// all others in `previous` that mount the same device as `mi`.
+fn is_best(previous: &[MountInfo], mi: &MountInfo) -> bool {
+    for seen in previous {
+        if seen.dev_id == mi.dev_id && mount_info_lt(mi, seen) {
+            return false;
+        }
+    }
+    true
+}
+
+/// Keep only the specified subset of [`MountInfo`] instances.
+///
+/// The `opt` argument specifies a variety of ways of excluding
+/// [`MountInfo`] instances; see [`Options`] for more information.
+///
+/// Finally, if there are duplicate entries, the one with the shorter
+/// path is kept.
+
+fn filter_mount_list(vmi: Vec<MountInfo>, opt: &Options) -> Vec<MountInfo> {
+    let mut result = vec![];
+    for mi in vmi {
+        // TODO The running time of the `is_best()` function is linear
+        // in the length of `result`. That makes the running time of
+        // this loop quadratic in the length of `vmi`. This could be
+        // improved by a more efficient implementation of `is_best()`,
+        // but `vmi` is probably not very long in practice.
+        if is_included(&mi, opt) && is_best(&result, &mi) {
+            result.push(mi);
+        }
+    }
+    result
+}
+
+/// Get all currently mounted filesystems.
+///
+/// `opt` excludes certain filesystems from consideration; see
+/// [`Options`] for more information.
+fn get_all_filesystems(opt: &Options) -> Vec<Filesystem> {
+    // The list of all mounted filesystems.
+    //
+    // Filesystems excluded by the command-line options are
+    // not considered.
+    let mounts: Vec<MountInfo> = filter_mount_list(read_fs_list(), opt);
+
+    // Convert each `MountInfo` into a `Filesystem`, which contains
+    // both the mount information and usage information.
+    mounts
         .into_iter()
-        .map(|ent| ent.1.into_inner())
-        .collect::<Vec<_>>()
+        .filter_map(|m| Filesystem::new(m, None))
+        .collect()
 }
 
-/// Convert `value` to a human readable string based on `base`.
-/// e.g. It returns 1G when value is 1 * 1024 * 1024 * 1024 and base is 1024.
-/// Note: It returns `value` if `base` isn't positive.
-fn human_readable(value: u64, base: i64) -> UResult<String> {
-    let base_str = match base {
-        d if d < 0 => value.to_string(),
+/// For each path, get the filesystem that contains that path.
+fn get_named_filesystems<P>(paths: &[P]) -> Vec<Filesystem>
+where
+    P: AsRef<Path>,
+{
+    // The list of all mounted filesystems.
+    //
+    // Filesystems marked as `dummy` or of type "lofs" are not
+    // considered. The "lofs" filesystem is a loopback
+    // filesystem present on Solaris and FreeBSD systems. It
+    // is similar to a symbolic link.
+    let mounts: Vec<MountInfo> = read_fs_list()
+        .into_iter()
+        .filter(|mi| mi.fs_type != "lofs" && !mi.dummy)
+        .collect();
 
-        // ref: [Binary prefix](https://en.wikipedia.org/wiki/Binary_prefix) @@ <https://archive.is/cnwmF>
-        // ref: [SI/metric prefix](https://en.wikipedia.org/wiki/Metric_prefix) @@ <https://archive.is/QIuLj>
-        1000 => match NumberPrefix::decimal(value as f64) {
-            NumberPrefix::Standalone(bytes) => bytes.to_string(),
-            NumberPrefix::Prefixed(prefix, bytes) => format!("{:.1}{}", bytes, prefix.symbol()),
-        },
-
-        1024 => match NumberPrefix::binary(value as f64) {
-            NumberPrefix::Standalone(bytes) => bytes.to_string(),
-            NumberPrefix::Prefixed(prefix, bytes) => format!("{:.1}{}", bytes, prefix.symbol()),
-        },
-
-        _ => return Err(DfError::InvalidBaseValue(base.to_string()).into()),
-    };
-
-    Ok(base_str)
-}
-
-fn use_size(free_size: u64, total_size: u64) -> String {
-    if total_size == 0 {
-        return String::from("-");
-    }
-    return format!(
-        "{:.0}%",
-        100f64 - 100f64 * (free_size as f64 / total_size as f64)
-    );
+    // Convert each path into a `Filesystem`, which contains
+    // both the mount information and usage information.
+    paths
+        .iter()
+        .filter_map(|p| Filesystem::from_path(&mounts, p))
+        .collect()
 }
 
 #[derive(Debug)]
 enum DfError {
-    InvalidBaseValue(String),
-}
-
-impl Display for DfError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            DfError::InvalidBaseValue(s) => write!(f, "Internal error: Unknown base value {}", s),
-        }
-    }
+    /// A problem while parsing command-line options.
+    OptionsError(OptionsError),
 }
 
 impl Error for DfError {}
 
 impl UError for DfError {
-    fn code(&self) -> i32 {
+    fn usage(&self) -> bool {
+        matches!(self, Self::OptionsError(OptionsError::ColumnError(_)))
+    }
+}
+
+impl fmt::Display for DfError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            DfError::InvalidBaseValue(_) => 1,
+            Self::OptionsError(e) => e.fmt(f),
         }
     }
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
-
-    let paths: Vec<String> = matches
-        .values_of(OPT_PATHS)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
-
+    let matches = uu_app().get_matches_from(args);
     #[cfg(windows)]
     {
         if matches.is_present(OPT_INODES) {
@@ -295,145 +317,61 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     }
 
-    let mut opt = Options::new();
-    if matches.is_present(OPT_LOCAL) {
-        opt.show_local_fs = true;
-    }
-    if matches.is_present(OPT_ALL) {
-        opt.show_all_fs = true;
-    }
-    if matches.is_present(OPT_INODES) {
-        opt.show_inode_instead = true;
-    }
-    if matches.is_present(OPT_PRINT_TYPE) {
-        opt.show_fs_type = true;
-    }
-    if matches.is_present(OPT_HUMAN_READABLE) {
-        opt.human_readable_base = 1024;
-    }
-    if matches.is_present(OPT_HUMAN_READABLE_2) {
-        opt.human_readable_base = 1000;
-    }
-    for fs_type in matches.values_of_lossy(OPT_TYPE).unwrap_or_default() {
-        opt.fs_selector.include(fs_type.to_owned());
-    }
-    for fs_type in matches
-        .values_of_lossy(OPT_EXCLUDE_TYPE)
-        .unwrap_or_default()
-    {
-        opt.fs_selector.exclude(fs_type.to_owned());
-    }
+    let opt = Options::from(&matches).map_err(DfError::OptionsError)?;
 
-    let fs_list = filter_mount_list(read_fs_list(), &paths, &opt)
-        .into_iter()
-        .filter_map(Filesystem::new)
-        .filter(|fs| fs.usage.blocks != 0 || opt.show_all_fs || opt.show_listed_fs)
-        .collect::<Vec<_>>();
+    // Get the list of filesystems to display in the output table.
+    let filesystems: Vec<Filesystem> = match matches.values_of(OPT_PATHS) {
+        None => get_all_filesystems(&opt),
+        Some(paths) => {
+            let paths: Vec<&str> = paths.collect();
+            get_named_filesystems(&paths)
+        }
+    };
 
-    // set headers
-    let mut header = vec!["Filesystem"];
-    if opt.show_fs_type {
-        header.push("Type");
-    }
-    header.extend_from_slice(&if opt.show_inode_instead {
-        // spell-checker:disable-next-line
-        ["Inodes", "Iused", "IFree", "IUses%"]
-    } else {
-        [
-            if opt.human_readable_base == -1 {
-                "1k-blocks"
-            } else {
-                "Size"
-            },
-            "Used",
-            "Available",
-            "Use%",
-        ]
-    });
-    if cfg!(target_os = "macos") && !opt.show_inode_instead {
-        header.insert(header.len() - 1, "Capacity");
-    }
-    header.push("Mounted on");
+    // The running total of filesystem sizes and usage.
+    //
+    // This accumulator is computed in case we need to display the
+    // total counts in the last row of the table.
+    let mut total = Row::new("total");
 
-    for (idx, title) in header.iter().enumerate() {
-        if idx == 0 || idx == header.len() - 1 {
-            print!("{0: <16} ", title);
-        } else if opt.show_fs_type && idx == 1 {
-            print!("{0: <5} ", title);
-        } else if idx == header.len() - 2 {
-            print!("{0: >5} ", title);
-        } else {
-            print!("{0: >12} ", title);
+    println!("{}", Header::new(&opt));
+    for filesystem in filesystems {
+        // If the filesystem is not empty, or if the options require
+        // showing all filesystems, then print the data as a row in
+        // the output table.
+        if opt.show_all_fs || opt.show_listed_fs || filesystem.usage.blocks > 0 {
+            let row = Row::from(filesystem);
+            println!("{}", DisplayRow::new(&row, &opt));
+            total += row;
         }
     }
-    println!();
-    for fs in fs_list.iter() {
-        print!("{0: <16} ", fs.mount_info.dev_name);
-        if opt.show_fs_type {
-            print!("{0: <5} ", fs.mount_info.fs_type);
-        }
-        if opt.show_inode_instead {
-            print!(
-                "{0: >12} ",
-                human_readable(fs.usage.files, opt.human_readable_base)?
-            );
-            print!(
-                "{0: >12} ",
-                human_readable(fs.usage.files - fs.usage.ffree, opt.human_readable_base)?
-            );
-            print!(
-                "{0: >12} ",
-                human_readable(fs.usage.ffree, opt.human_readable_base)?
-            );
-            print!(
-                "{0: >5} ",
-                format!(
-                    "{0:.1}%",
-                    100f64 - 100f64 * (fs.usage.ffree as f64 / fs.usage.files as f64)
-                )
-            );
-        } else {
-            let total_size = fs.usage.blocksize * fs.usage.blocks;
-            let free_size = fs.usage.blocksize * fs.usage.bfree;
-            print!(
-                "{0: >12} ",
-                human_readable(total_size, opt.human_readable_base)?
-            );
-            print!(
-                "{0: >12} ",
-                human_readable(total_size - free_size, opt.human_readable_base)?
-            );
-            print!(
-                "{0: >12} ",
-                human_readable(free_size, opt.human_readable_base)?
-            );
-            if cfg!(target_os = "macos") {
-                let used = fs.usage.blocks - fs.usage.bfree;
-                let blocks = used + fs.usage.bavail;
-                print!("{0: >12} ", use_size(used, blocks));
-            }
-            print!("{0: >5} ", use_size(free_size, total_size));
-        }
-        print!("{0: <16}", fs.mount_info.mount_dir);
-        println!();
+    if opt.show_total {
+        println!("{}", DisplayRow::new(&total, &opt));
     }
 
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_ALL)
-                .short("a")
+            Arg::new(OPT_HELP)
+                .long(OPT_HELP)
+                .help("Print help information."),
+        )
+        .arg(
+            Arg::new(OPT_ALL)
+                .short('a')
                 .long("all")
                 .help("include dummy file systems"),
         )
         .arg(
-            Arg::with_name(OPT_BLOCKSIZE)
-                .short("B")
+            Arg::new(OPT_BLOCKSIZE)
+                .short('B')
                 .long("block-size")
                 .takes_value(true)
                 .help(
@@ -442,96 +380,361 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_DIRECT)
-                .long("direct")
-                .help("show statistics for a file instead of mount point"),
-        )
-        .arg(
-            Arg::with_name(OPT_TOTAL)
+            Arg::new(OPT_TOTAL)
                 .long("total")
                 .help("produce a grand total"),
         )
         .arg(
-            Arg::with_name(OPT_HUMAN_READABLE)
-                .short("h")
+            Arg::new(OPT_HUMAN_READABLE_BINARY)
+                .short('h')
                 .long("human-readable")
-                .conflicts_with(OPT_HUMAN_READABLE_2)
+                .conflicts_with(OPT_HUMAN_READABLE_DECIMAL)
                 .help("print sizes in human readable format (e.g., 1K 234M 2G)"),
         )
         .arg(
-            Arg::with_name(OPT_HUMAN_READABLE_2)
-                .short("H")
+            Arg::new(OPT_HUMAN_READABLE_DECIMAL)
+                .short('H')
                 .long("si")
-                .conflicts_with(OPT_HUMAN_READABLE)
+                .conflicts_with(OPT_HUMAN_READABLE_BINARY)
                 .help("likewise, but use powers of 1000 not 1024"),
         )
         .arg(
-            Arg::with_name(OPT_INODES)
-                .short("i")
+            Arg::new(OPT_INODES)
+                .short('i')
                 .long("inodes")
                 .help("list inode information instead of block usage"),
         )
+        .arg(Arg::new(OPT_KILO).short('k').help("like --block-size=1K"))
         .arg(
-            Arg::with_name(OPT_KILO)
-                .short("k")
-                .help("like --block-size=1K"),
-        )
-        .arg(
-            Arg::with_name(OPT_LOCAL)
-                .short("l")
+            Arg::new(OPT_LOCAL)
+                .short('l')
                 .long("local")
                 .help("limit listing to local file systems"),
         )
         .arg(
-            Arg::with_name(OPT_NO_SYNC)
+            Arg::new(OPT_NO_SYNC)
                 .long("no-sync")
                 .conflicts_with(OPT_SYNC)
                 .help("do not invoke sync before getting usage info (default)"),
         )
         .arg(
-            Arg::with_name(OPT_OUTPUT)
+            Arg::new(OPT_OUTPUT)
                 .long("output")
                 .takes_value(true)
-                .use_delimiter(true)
+                .min_values(0)
+                .require_equals(true)
+                .use_value_delimiter(true)
+                .multiple_occurrences(true)
+                .possible_values(OUTPUT_FIELD_LIST)
+                .default_missing_values(&OUTPUT_FIELD_LIST)
+                .default_values(&["source", "size", "used", "avail", "pcent", "target"])
+                .conflicts_with_all(&[OPT_INODES, OPT_PORTABILITY, OPT_PRINT_TYPE])
                 .help(
                     "use the output format defined by FIELD_LIST,\
                      or print all fields if FIELD_LIST is omitted.",
                 ),
         )
         .arg(
-            Arg::with_name(OPT_PORTABILITY)
-                .short("P")
+            Arg::new(OPT_PORTABILITY)
+                .short('P')
                 .long("portability")
                 .help("use the POSIX output format"),
         )
         .arg(
-            Arg::with_name(OPT_SYNC)
+            Arg::new(OPT_SYNC)
                 .long("sync")
                 .conflicts_with(OPT_NO_SYNC)
                 .help("invoke sync before getting usage info"),
         )
         .arg(
-            Arg::with_name(OPT_TYPE)
-                .short("t")
+            Arg::new(OPT_TYPE)
+                .short('t')
                 .long("type")
+                .allow_invalid_utf8(true)
                 .takes_value(true)
-                .use_delimiter(true)
+                .multiple_occurrences(true)
                 .help("limit listing to file systems of type TYPE"),
         )
         .arg(
-            Arg::with_name(OPT_PRINT_TYPE)
-                .short("T")
+            Arg::new(OPT_PRINT_TYPE)
+                .short('T')
                 .long("print-type")
                 .help("print file system type"),
         )
         .arg(
-            Arg::with_name(OPT_EXCLUDE_TYPE)
-                .short("x")
+            Arg::new(OPT_EXCLUDE_TYPE)
+                .short('x')
                 .long("exclude-type")
+                .allow_invalid_utf8(true)
                 .takes_value(true)
-                .use_delimiter(true)
+                .use_value_delimiter(true)
+                .multiple_occurrences(true)
                 .help("limit listing to file systems not of type TYPE"),
         )
-        .arg(Arg::with_name(OPT_PATHS).multiple(true))
-        .help("Filesystem(s) to list")
+        .arg(Arg::new(OPT_PATHS).multiple_occurrences(true))
+}
+
+#[cfg(test)]
+mod tests {
+
+    mod mount_info_lt {
+
+        use crate::mount_info_lt;
+        use uucore::fsext::MountInfo;
+
+        /// Instantiate a [`MountInfo`] with the given fields.
+        fn mount_info(dev_name: &str, mount_root: &str, mount_dir: &str) -> MountInfo {
+            MountInfo {
+                dev_id: String::new(),
+                dev_name: String::from(dev_name),
+                fs_type: String::new(),
+                mount_dir: String::from(mount_dir),
+                mount_option: String::new(),
+                mount_root: String::from(mount_root),
+                remote: false,
+                dummy: false,
+            }
+        }
+
+        #[test]
+        fn test_absolute() {
+            // Prefer device name "/dev/foo" over "dev_foo".
+            let m1 = mount_info("/dev/foo", "/", "/mnt/bar");
+            let m2 = mount_info("dev_foo", "/", "/mnt/bar");
+            assert!(!mount_info_lt(&m1, &m2));
+        }
+
+        #[test]
+        fn test_shorter() {
+            // Prefer mount directory "/mnt/bar" over "/mnt/bar/baz"...
+            let m1 = mount_info("/dev/foo", "/", "/mnt/bar");
+            let m2 = mount_info("/dev/foo", "/", "/mnt/bar/baz");
+            assert!(!mount_info_lt(&m1, &m2));
+
+            // ..but prefer mount root "/root" over "/".
+            let m1 = mount_info("/dev/foo", "/root", "/mnt/bar");
+            let m2 = mount_info("/dev/foo", "/", "/mnt/bar/baz");
+            assert!(mount_info_lt(&m1, &m2));
+        }
+
+        #[test]
+        fn test_over_mounted() {
+            // Prefer the earlier entry if the devices are different but
+            // the mount directory is the same.
+            let m1 = mount_info("/dev/foo", "/", "/mnt/baz");
+            let m2 = mount_info("/dev/bar", "/", "/mnt/baz");
+            assert!(!mount_info_lt(&m1, &m2));
+        }
+    }
+
+    mod is_best {
+
+        use crate::is_best;
+        use uucore::fsext::MountInfo;
+
+        /// Instantiate a [`MountInfo`] with the given fields.
+        fn mount_info(dev_id: &str, mount_dir: &str) -> MountInfo {
+            MountInfo {
+                dev_id: String::from(dev_id),
+                dev_name: String::new(),
+                fs_type: String::new(),
+                mount_dir: String::from(mount_dir),
+                mount_option: String::new(),
+                mount_root: String::new(),
+                remote: false,
+                dummy: false,
+            }
+        }
+
+        #[test]
+        fn test_empty() {
+            let m = mount_info("0", "/mnt/bar");
+            assert!(is_best(&[], &m));
+        }
+
+        #[test]
+        fn test_different_dev_id() {
+            let m1 = mount_info("0", "/mnt/bar");
+            let m2 = mount_info("1", "/mnt/bar");
+            assert!(is_best(&[m1.clone()], &m2));
+            assert!(is_best(&[m2], &m1));
+        }
+
+        #[test]
+        fn test_same_dev_id() {
+            // There are several conditions under which a `MountInfo` is
+            // considered "better" than the others, we're just checking
+            // one condition in this test.
+            let m1 = mount_info("0", "/mnt/bar");
+            let m2 = mount_info("0", "/mnt/bar/baz");
+            assert!(!is_best(&[m1.clone()], &m2));
+            assert!(is_best(&[m2], &m1));
+        }
+    }
+
+    mod is_included {
+
+        use crate::{is_included, Options};
+        use uucore::fsext::MountInfo;
+
+        /// Instantiate a [`MountInfo`] with the given fields.
+        fn mount_info(fs_type: &str, mount_dir: &str, remote: bool, dummy: bool) -> MountInfo {
+            MountInfo {
+                dev_id: String::new(),
+                dev_name: String::new(),
+                fs_type: String::from(fs_type),
+                mount_dir: String::from(mount_dir),
+                mount_option: String::new(),
+                mount_root: String::new(),
+                remote,
+                dummy,
+            }
+        }
+
+        #[test]
+        fn test_remote_included() {
+            let opt = Default::default();
+            let m = mount_info("ext4", "/mnt/foo", true, false);
+            assert!(is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_remote_excluded() {
+            let opt = Options {
+                show_local_fs: true,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", true, false);
+            assert!(!is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_dummy_included() {
+            let opt = Options {
+                show_all_fs: true,
+                show_listed_fs: true,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, true);
+            assert!(is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_dummy_excluded() {
+            let opt = Default::default();
+            let m = mount_info("ext4", "/mnt/foo", false, true);
+            assert!(!is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_exclude_match() {
+            let exclude = Some(vec![String::from("ext4")]);
+            let opt = Options {
+                exclude,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(!is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_exclude_no_match() {
+            let exclude = Some(vec![String::from("tmpfs")]);
+            let opt = Options {
+                exclude,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_include_match() {
+            let include = Some(vec![String::from("ext4")]);
+            let opt = Options {
+                include,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_include_no_match() {
+            let include = Some(vec![String::from("tmpfs")]);
+            let opt = Options {
+                include,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(!is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_include_and_exclude_match_neither() {
+            let include = Some(vec![String::from("tmpfs")]);
+            let exclude = Some(vec![String::from("squashfs")]);
+            let opt = Options {
+                include,
+                exclude,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(!is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_include_and_exclude_match_exclude() {
+            let include = Some(vec![String::from("tmpfs")]);
+            let exclude = Some(vec![String::from("ext4")]);
+            let opt = Options {
+                include,
+                exclude,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(!is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_include_and_exclude_match_include() {
+            let include = Some(vec![String::from("ext4")]);
+            let exclude = Some(vec![String::from("squashfs")]);
+            let opt = Options {
+                include,
+                exclude,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(is_included(&m, &opt));
+        }
+
+        #[test]
+        fn test_include_and_exclude_match_both() {
+            // TODO The same filesystem type in both `include` and
+            // `exclude` should cause an error, but currently does
+            // not.
+            let include = Some(vec![String::from("ext4")]);
+            let exclude = Some(vec![String::from("ext4")]);
+            let opt = Options {
+                include,
+                exclude,
+                ..Default::default()
+            };
+            let m = mount_info("ext4", "/mnt/foo", false, false);
+            assert!(!is_included(&m, &opt));
+        }
+    }
+
+    mod filter_mount_list {
+
+        use crate::filter_mount_list;
+
+        #[test]
+        fn test_empty() {
+            let opt = Default::default();
+            let mount_infos = vec![];
+            assert!(filter_mount_list(mount_infos, &opt).is_empty());
+        }
+    }
 }
diff --git a/src/uu/df/src/filesystem.rs b/src/uu/df/src/filesystem.rs
new file mode 100644
index 000000000..00b810073
--- /dev/null
+++ b/src/uu/df/src/filesystem.rs
@@ -0,0 +1,203 @@
+//  * 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.
+//! Provides a summary representation of a filesystem.
+//!
+//! A [`Filesystem`] struct represents a device containing a
+//! filesystem mounted at a particular directory. It also includes
+//! information on amount of space available and amount of space used.
+// spell-checker:ignore canonicalized
+use std::path::Path;
+
+#[cfg(unix)]
+use uucore::fsext::statfs;
+use uucore::fsext::{FsUsage, MountInfo};
+
+/// Summary representation of a filesystem.
+///
+/// A [`Filesystem`] struct represents a device containing a
+/// filesystem mounted at a particular directory. The
+/// [`Filesystem::mount_info`] field exposes that information. The
+/// [`Filesystem::usage`] field provides information on the amount of
+/// space available on the filesystem and the amount of space used.
+#[derive(Debug, Clone)]
+pub(crate) struct Filesystem {
+    /// The file given on the command line if any.
+    ///
+    /// When invoking `df` with a positional argument, it displays
+    /// usage information for the filesystem that contains the given
+    /// file. If given, this field contains that filename.
+    pub file: Option<String>,
+
+    /// Information about the mounted device, mount directory, and related options.
+    pub mount_info: MountInfo,
+
+    /// Information about the amount of space used on the filesystem.
+    pub usage: FsUsage,
+}
+
+/// Find the mount info that best matches a given filesystem path.
+///
+/// This function returns the element of `mounts` on which `path` is
+/// mounted. If there are no matches, this function returns
+/// [`None`]. If there are two or more matches, then the single
+/// [`MountInfo`] with the longest mount directory is returned.
+///
+/// If `canonicalize` is `true`, then the `path` is canonicalized
+/// before checking whether it matches any mount directories.
+///
+/// # See also
+///
+/// * [`Path::canonicalize`]
+/// * [`MountInfo::mount_dir`]
+fn mount_info_from_path<P>(
+    mounts: &[MountInfo],
+    path: P,
+    // This is really only used for testing purposes.
+    canonicalize: bool,
+) -> Option<&MountInfo>
+where
+    P: AsRef<Path>,
+{
+    // TODO Refactor this function with `Stater::find_mount_point()`
+    // in the `stat` crate.
+    let path = if canonicalize {
+        path.as_ref().canonicalize().ok()?
+    } else {
+        path.as_ref().to_path_buf()
+    };
+    let matches = mounts.iter().filter(|mi| path.starts_with(&mi.mount_dir));
+    matches.max_by_key(|mi| mi.mount_dir.len())
+}
+
+impl Filesystem {
+    // TODO: resolve uuid in `mount_info.dev_name` if exists
+    pub(crate) fn new(mount_info: MountInfo, file: Option<String>) -> Option<Self> {
+        let _stat_path = if !mount_info.mount_dir.is_empty() {
+            mount_info.mount_dir.clone()
+        } else {
+            #[cfg(unix)]
+            {
+                mount_info.dev_name.clone()
+            }
+            #[cfg(windows)]
+            {
+                // On windows, we expect the volume id
+                mount_info.dev_id.clone()
+            }
+        };
+        #[cfg(unix)]
+        let usage = FsUsage::new(statfs(_stat_path).ok()?);
+        #[cfg(windows)]
+        let usage = FsUsage::new(Path::new(&_stat_path));
+        Some(Self {
+            mount_info,
+            usage,
+            file,
+        })
+    }
+
+    /// Find and create the filesystem that best matches a given path.
+    ///
+    /// This function returns a new `Filesystem` derived from the
+    /// element of `mounts` on which `path` is mounted. If there are
+    /// no matches, this function returns [`None`]. If there are two
+    /// or more matches, then the single [`Filesystem`] with the
+    /// longest mount directory is returned.
+    ///
+    /// The `path` is canonicalized before checking whether it matches
+    /// any mount directories.
+    ///
+    /// # See also
+    ///
+    /// * [`Path::canonicalize`]
+    /// * [`MountInfo::mount_dir`]
+    ///
+    pub(crate) fn from_path<P>(mounts: &[MountInfo], path: P) -> Option<Self>
+    where
+        P: AsRef<Path>,
+    {
+        let file = path.as_ref().display().to_string();
+        let canonicalize = true;
+        let mount_info = mount_info_from_path(mounts, path, canonicalize)?;
+        // TODO Make it so that we do not need to clone the `mount_info`.
+        let mount_info = (*mount_info).clone();
+        Self::new(mount_info, Some(file))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    mod mount_info_from_path {
+
+        use uucore::fsext::MountInfo;
+
+        use crate::filesystem::mount_info_from_path;
+
+        // Create a fake `MountInfo` with the given directory name.
+        fn mount_info(mount_dir: &str) -> MountInfo {
+            MountInfo {
+                dev_id: Default::default(),
+                dev_name: Default::default(),
+                fs_type: Default::default(),
+                mount_dir: String::from(mount_dir),
+                mount_option: Default::default(),
+                mount_root: Default::default(),
+                remote: Default::default(),
+                dummy: Default::default(),
+            }
+        }
+
+        // Check whether two `MountInfo` instances are equal.
+        fn mount_info_eq(m1: &MountInfo, m2: &MountInfo) -> bool {
+            m1.dev_id == m2.dev_id
+                && m1.dev_name == m2.dev_name
+                && m1.fs_type == m2.fs_type
+                && m1.mount_dir == m2.mount_dir
+                && m1.mount_option == m2.mount_option
+                && m1.mount_root == m2.mount_root
+                && m1.remote == m2.remote
+                && m1.dummy == m2.dummy
+        }
+
+        #[test]
+        fn test_empty_mounts() {
+            assert!(mount_info_from_path(&[], "/", false).is_none());
+        }
+
+        #[test]
+        fn test_exact_match() {
+            let mounts = [mount_info("/foo")];
+            let actual = mount_info_from_path(&mounts, "/foo", false).unwrap();
+            assert!(mount_info_eq(actual, &mounts[0]));
+        }
+
+        #[test]
+        fn test_prefix_match() {
+            let mounts = [mount_info("/foo")];
+            let actual = mount_info_from_path(&mounts, "/foo/bar", false).unwrap();
+            assert!(mount_info_eq(actual, &mounts[0]));
+        }
+
+        #[test]
+        fn test_multiple_matches() {
+            let mounts = [mount_info("/foo"), mount_info("/foo/bar")];
+            let actual = mount_info_from_path(&mounts, "/foo/bar", false).unwrap();
+            assert!(mount_info_eq(actual, &mounts[1]));
+        }
+
+        #[test]
+        fn test_no_match() {
+            let mounts = [mount_info("/foo")];
+            assert!(mount_info_from_path(&mounts, "/bar", false).is_none());
+        }
+
+        #[test]
+        fn test_partial_match() {
+            let mounts = [mount_info("/foo/bar")];
+            assert!(mount_info_from_path(&mounts, "/foo/baz", false).is_none());
+        }
+    }
+}
diff --git a/src/uu/df/src/main.rs b/src/uu/df/src/main.rs
index a6d403782..3868d685a 100644
--- a/src/uu/df/src/main.rs
+++ b/src/uu/df/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_df);
+uucore::bin!(uu_df);
diff --git a/src/uu/df/src/table.rs b/src/uu/df/src/table.rs
new file mode 100644
index 000000000..0f4daa0e1
--- /dev/null
+++ b/src/uu/df/src/table.rs
@@ -0,0 +1,606 @@
+//  * 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 tmpfs Pcent Itotal Iused Iavail Ipcent
+//! The filesystem usage data table.
+//!
+//! A table comprises a header row ([`Header`]) and a collection of
+//! data rows ([`Row`]), one per filesystem. To display a [`Row`],
+//! combine it with [`Options`] in the [`DisplayRow`] struct; the
+//! [`DisplayRow`] implements [`std::fmt::Display`].
+use number_prefix::NumberPrefix;
+
+use crate::columns::Column;
+use crate::filesystem::Filesystem;
+use crate::{BlockSize, Options};
+use uucore::fsext::{FsUsage, MountInfo};
+
+use std::fmt;
+use std::ops::AddAssign;
+
+/// A row in the filesystem usage data table.
+///
+/// A row comprises several pieces of information, including the
+/// filesystem device, the mountpoint, the number of bytes used, etc.
+pub(crate) struct Row {
+    /// The filename given on the command-line, if given.
+    file: Option<String>,
+
+    /// Name of the device on which the filesystem lives.
+    fs_device: String,
+
+    /// Type of filesystem (for example, `"ext4"`, `"tmpfs"`, etc.).
+    fs_type: String,
+
+    /// Path at which the filesystem is mounted.
+    fs_mount: String,
+
+    /// Total number of bytes in the filesystem regardless of whether they are used.
+    bytes: u64,
+
+    /// Number of used bytes.
+    bytes_used: u64,
+
+    /// Number of available bytes.
+    bytes_avail: u64,
+
+    /// Percentage of bytes that are used, given as a float between 0 and 1.
+    ///
+    /// If the filesystem has zero bytes, then this is `None`.
+    bytes_usage: Option<f64>,
+
+    /// Percentage of bytes that are available, given as a float between 0 and 1.
+    ///
+    /// These are the bytes that are available to non-privileged processes.
+    ///
+    /// If the filesystem has zero bytes, then this is `None`.
+    #[cfg(target_os = "macos")]
+    bytes_capacity: Option<f64>,
+
+    /// Total number of inodes in the filesystem.
+    inodes: u64,
+
+    /// Number of used inodes.
+    inodes_used: u64,
+
+    /// Number of free inodes.
+    inodes_free: u64,
+
+    /// Percentage of inodes that are used, given as a float between 0 and 1.
+    ///
+    /// If the filesystem has zero bytes, then this is `None`.
+    inodes_usage: Option<f64>,
+}
+
+impl Row {
+    pub(crate) fn new(source: &str) -> Self {
+        Self {
+            file: None,
+            fs_device: source.into(),
+            fs_type: "-".into(),
+            fs_mount: "-".into(),
+            bytes: 0,
+            bytes_used: 0,
+            bytes_avail: 0,
+            bytes_usage: None,
+            #[cfg(target_os = "macos")]
+            bytes_capacity: None,
+            inodes: 0,
+            inodes_used: 0,
+            inodes_free: 0,
+            inodes_usage: None,
+        }
+    }
+}
+
+impl AddAssign for Row {
+    /// Sum the numeric values of two rows.
+    ///
+    /// The `Row::fs_device` field is set to `"total"` and the
+    /// remaining `String` fields are set to `"-"`.
+    fn add_assign(&mut self, rhs: Self) {
+        let bytes = self.bytes + rhs.bytes;
+        let bytes_used = self.bytes_used + rhs.bytes_used;
+        let bytes_avail = self.bytes_avail + rhs.bytes_avail;
+        let inodes = self.inodes + rhs.inodes;
+        let inodes_used = self.inodes_used + rhs.inodes_used;
+        *self = Self {
+            file: None,
+            fs_device: "total".into(),
+            fs_type: "-".into(),
+            fs_mount: "-".into(),
+            bytes,
+            bytes_used,
+            bytes_avail,
+            bytes_usage: if bytes == 0 {
+                None
+            } else {
+                // We use "(bytes_used + bytes_avail)" instead of "bytes" because on some filesystems (e.g.
+                // ext4) "bytes" also includes reserved blocks we ignore for the usage calculation.
+                // https://www.gnu.org/software/coreutils/faq/coreutils-faq.html#df-Size-and-Used-and-Available-do-not-add-up
+                Some(bytes_used as f64 / (bytes_used + bytes_avail) as f64)
+            },
+            // TODO Figure out how to compute this.
+            #[cfg(target_os = "macos")]
+            bytes_capacity: None,
+            inodes,
+            inodes_used,
+            inodes_free: self.inodes_free + rhs.inodes_free,
+            inodes_usage: if inodes == 0 {
+                None
+            } else {
+                Some(inodes_used as f64 / inodes as f64)
+            },
+        }
+    }
+}
+
+impl From<Filesystem> for Row {
+    fn from(fs: Filesystem) -> Self {
+        let MountInfo {
+            dev_name,
+            fs_type,
+            mount_dir,
+            ..
+        } = fs.mount_info;
+        let FsUsage {
+            blocksize,
+            blocks,
+            bfree,
+            bavail,
+            files,
+            ffree,
+            ..
+        } = fs.usage;
+        let bused = blocks - bfree;
+        Self {
+            file: fs.file,
+            fs_device: dev_name,
+            fs_type,
+            fs_mount: mount_dir,
+            bytes: blocksize * blocks,
+            bytes_used: blocksize * bused,
+            bytes_avail: blocksize * bavail,
+            bytes_usage: if blocks == 0 {
+                None
+            } else {
+                // We use "(bused + bavail)" instead of "blocks" because on some filesystems (e.g.
+                // ext4) "blocks" also includes reserved blocks we ignore for the usage calculation.
+                // https://www.gnu.org/software/coreutils/faq/coreutils-faq.html#df-Size-and-Used-and-Available-do-not-add-up
+                Some(bused as f64 / (bused + bavail) as f64)
+            },
+            #[cfg(target_os = "macos")]
+            bytes_capacity: if bavail == 0 {
+                None
+            } else {
+                Some(bavail as f64 / ((bused + bavail) as f64))
+            },
+            inodes: files,
+            inodes_used: files - ffree,
+            inodes_free: ffree,
+            inodes_usage: if files == 0 {
+                None
+            } else {
+                Some(ffree as f64 / files as f64)
+            },
+        }
+    }
+}
+
+/// A displayable wrapper around a [`Row`].
+///
+/// The `options` control how the information in the row gets displayed.
+pub(crate) struct DisplayRow<'a> {
+    /// The data in this row.
+    row: &'a Row,
+
+    /// Options that control how to display the data.
+    options: &'a Options,
+    // TODO We don't need all of the command-line options here. Some
+    // of the command-line options indicate which rows to include or
+    // exclude. Other command-line options indicate which columns to
+    // include or exclude. Still other options indicate how to format
+    // numbers. We could split the options up into those groups to
+    // reduce the coupling between this `table.rs` module and the main
+    // `df.rs` module.
+}
+
+impl<'a> DisplayRow<'a> {
+    /// Instantiate this struct.
+    pub(crate) fn new(row: &'a Row, options: &'a Options) -> Self {
+        Self { row, options }
+    }
+
+    /// Get a string giving the scaled version of the input number.
+    ///
+    /// The scaling factor is defined in the `options` field.
+    ///
+    /// # Errors
+    ///
+    /// If the scaling factor is not 1000, 1024, or a negative number.
+    fn scaled(&self, size: u64) -> Result<String, fmt::Error> {
+        let number_prefix = match self.options.block_size {
+            BlockSize::HumanReadableDecimal => NumberPrefix::decimal(size as f64),
+            BlockSize::HumanReadableBinary => NumberPrefix::binary(size as f64),
+            BlockSize::Bytes(d) => return Ok((size / d).to_string()),
+        };
+        match number_prefix {
+            NumberPrefix::Standalone(bytes) => Ok(bytes.to_string()),
+            NumberPrefix::Prefixed(prefix, bytes) => Ok(format!("{:.1}{}", bytes, prefix.symbol())),
+        }
+    }
+
+    /// Convert a float between 0 and 1 into a percentage string.
+    ///
+    /// If `None`, return the string `"-"` instead.
+    fn percentage(fraction: Option<f64>) -> String {
+        match fraction {
+            None => "-".to_string(),
+            Some(x) => format!("{:.0}%", (100.0 * x).ceil()),
+        }
+    }
+}
+
+impl fmt::Display for DisplayRow<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for column in &self.options.columns {
+            match column {
+                Column::Source => write!(f, "{0: <16} ", self.row.fs_device)?,
+                Column::Size => write!(f, "{0: >12} ", self.scaled(self.row.bytes)?)?,
+                Column::Used => write!(f, "{0: >12} ", self.scaled(self.row.bytes_used)?)?,
+                Column::Avail => write!(f, "{0: >12} ", self.scaled(self.row.bytes_avail)?)?,
+                Column::Pcent => {
+                    write!(f, "{0: >5} ", DisplayRow::percentage(self.row.bytes_usage))?;
+                }
+                Column::Target => write!(f, "{0: <16}", self.row.fs_mount)?,
+                Column::Itotal => write!(f, "{0: >12} ", self.scaled(self.row.inodes)?)?,
+                Column::Iused => write!(f, "{0: >12} ", self.scaled(self.row.inodes_used)?)?,
+                Column::Iavail => write!(f, "{0: >12} ", self.scaled(self.row.inodes_free)?)?,
+                Column::Ipcent => {
+                    write!(f, "{0: >5} ", DisplayRow::percentage(self.row.inodes_usage))?;
+                }
+                Column::File => {
+                    write!(f, "{0: <16}", self.row.file.as_ref().unwrap_or(&"-".into()))?;
+                }
+                Column::Fstype => write!(f, "{0: <5} ", self.row.fs_type)?,
+                #[cfg(target_os = "macos")]
+                Column::Capacity => write!(
+                    f,
+                    "{0: >12} ",
+                    DisplayRow::percentage(self.row.bytes_capacity)
+                )?,
+            }
+        }
+        Ok(())
+    }
+}
+
+/// The header row.
+///
+/// The `options` control which columns are displayed.
+pub(crate) struct Header<'a> {
+    /// Options that control which columns are displayed.
+    options: &'a Options,
+}
+
+impl<'a> Header<'a> {
+    /// Instantiate this struct.
+    pub(crate) fn new(options: &'a Options) -> Self {
+        Self { options }
+    }
+}
+
+impl fmt::Display for Header<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for column in &self.options.columns {
+            match column {
+                Column::Source => write!(f, "{0: <16} ", "Filesystem")?,
+                // `Display` is implemented for `BlockSize`, but
+                // `Display` only works when formatting an object into
+                // an empty format, `{}`. So we use `format!()` first
+                // to create the string, then use `write!()` to align
+                // the string and pad with spaces.
+                Column::Size => write!(f, "{0: >12} ", format!("{}", self.options.block_size))?,
+                Column::Used => write!(f, "{0: >12} ", "Used")?,
+                Column::Avail => write!(f, "{0: >12} ", "Available")?,
+                Column::Pcent => write!(f, "{0: >5} ", "Use%")?,
+                Column::Target => write!(f, "{0: <16} ", "Mounted on")?,
+                Column::Itotal => write!(f, "{0: >12} ", "Inodes")?,
+                Column::Iused => write!(f, "{0: >12} ", "IUsed")?,
+                Column::Iavail => write!(f, "{0: >12} ", "IFree")?,
+                Column::Ipcent => write!(f, "{0: >5} ", "IUse%")?,
+                Column::File => write!(f, "{0: <16}", "File")?,
+                Column::Fstype => write!(f, "{0: <5} ", "Type")?,
+                #[cfg(target_os = "macos")]
+                Column::Capacity => write!(f, "{0: >12} ", "Capacity")?,
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::columns::Column;
+    use crate::table::{DisplayRow, Header, Row};
+    use crate::{BlockSize, Options};
+
+    const COLUMNS_WITH_FS_TYPE: [Column; 7] = [
+        Column::Source,
+        Column::Fstype,
+        Column::Size,
+        Column::Used,
+        Column::Avail,
+        Column::Pcent,
+        Column::Target,
+    ];
+    const COLUMNS_WITH_INODES: [Column; 6] = [
+        Column::Source,
+        Column::Itotal,
+        Column::Iused,
+        Column::Iavail,
+        Column::Ipcent,
+        Column::Target,
+    ];
+
+    #[test]
+    fn test_header_display() {
+        let options = Default::default();
+        assert_eq!(
+            Header::new(&options).to_string(),
+            "Filesystem          1K-blocks         Used    Available  Use% Mounted on       "
+        );
+    }
+
+    #[test]
+    fn test_header_display_fs_type() {
+        let options = Options {
+            columns: COLUMNS_WITH_FS_TYPE.to_vec(),
+            ..Default::default()
+        };
+        assert_eq!(
+            Header::new(&options).to_string(),
+            "Filesystem       Type     1K-blocks         Used    Available  Use% Mounted on       "
+        );
+    }
+
+    #[test]
+    fn test_header_display_inode() {
+        let options = Options {
+            columns: COLUMNS_WITH_INODES.to_vec(),
+            ..Default::default()
+        };
+        assert_eq!(
+            Header::new(&options).to_string(),
+            "Filesystem             Inodes        IUsed        IFree IUse% Mounted on       "
+        );
+    }
+
+    #[test]
+    fn test_header_display_block_size_1024() {
+        let options = Options {
+            block_size: BlockSize::Bytes(3 * 1024),
+            ..Default::default()
+        };
+        assert_eq!(
+            Header::new(&options).to_string(),
+            "Filesystem          3K-blocks         Used    Available  Use% Mounted on       "
+        );
+    }
+
+    #[test]
+    fn test_header_display_human_readable_binary() {
+        let options = Options {
+            block_size: BlockSize::HumanReadableBinary,
+            ..Default::default()
+        };
+        assert_eq!(
+            Header::new(&options).to_string(),
+            "Filesystem               Size         Used    Available  Use% Mounted on       "
+        );
+    }
+
+    #[test]
+    fn test_header_display_human_readable_si() {
+        let options = Options {
+            block_size: BlockSize::HumanReadableDecimal,
+            ..Default::default()
+        };
+        assert_eq!(
+            Header::new(&options).to_string(),
+            "Filesystem               Size         Used    Available  Use% Mounted on       "
+        );
+    }
+
+    #[test]
+    fn test_row_display() {
+        let options = Options {
+            block_size: BlockSize::Bytes(1),
+            ..Default::default()
+        };
+        let row = Row {
+            file: Some("/path/to/file".to_string()),
+            fs_device: "my_device".to_string(),
+            fs_type: "my_type".to_string(),
+            fs_mount: "my_mount".to_string(),
+
+            bytes: 100,
+            bytes_used: 25,
+            bytes_avail: 75,
+            bytes_usage: Some(0.25),
+
+            #[cfg(target_os = "macos")]
+            bytes_capacity: Some(0.5),
+
+            inodes: 10,
+            inodes_used: 2,
+            inodes_free: 8,
+            inodes_usage: Some(0.2),
+        };
+        assert_eq!(
+            DisplayRow::new(&row, &options).to_string(),
+            "my_device                 100           25           75   25% my_mount        "
+        );
+    }
+
+    #[test]
+    fn test_row_display_fs_type() {
+        let options = Options {
+            columns: COLUMNS_WITH_FS_TYPE.to_vec(),
+            block_size: BlockSize::Bytes(1),
+            ..Default::default()
+        };
+        let row = Row {
+            file: Some("/path/to/file".to_string()),
+            fs_device: "my_device".to_string(),
+            fs_type: "my_type".to_string(),
+            fs_mount: "my_mount".to_string(),
+
+            bytes: 100,
+            bytes_used: 25,
+            bytes_avail: 75,
+            bytes_usage: Some(0.25),
+
+            #[cfg(target_os = "macos")]
+            bytes_capacity: Some(0.5),
+
+            inodes: 10,
+            inodes_used: 2,
+            inodes_free: 8,
+            inodes_usage: Some(0.2),
+        };
+        assert_eq!(
+            DisplayRow::new(&row, &options).to_string(),
+            "my_device        my_type          100           25           75   25% my_mount        "
+        );
+    }
+
+    #[test]
+    fn test_row_display_inodes() {
+        let options = Options {
+            columns: COLUMNS_WITH_INODES.to_vec(),
+            block_size: BlockSize::Bytes(1),
+            ..Default::default()
+        };
+        let row = Row {
+            file: Some("/path/to/file".to_string()),
+            fs_device: "my_device".to_string(),
+            fs_type: "my_type".to_string(),
+            fs_mount: "my_mount".to_string(),
+
+            bytes: 100,
+            bytes_used: 25,
+            bytes_avail: 75,
+            bytes_usage: Some(0.25),
+
+            #[cfg(target_os = "macos")]
+            bytes_capacity: Some(0.5),
+
+            inodes: 10,
+            inodes_used: 2,
+            inodes_free: 8,
+            inodes_usage: Some(0.2),
+        };
+        assert_eq!(
+            DisplayRow::new(&row, &options).to_string(),
+            "my_device                  10            2            8   20% my_mount        "
+        );
+    }
+
+    #[test]
+    fn test_row_display_human_readable_si() {
+        let options = Options {
+            block_size: BlockSize::HumanReadableDecimal,
+            columns: COLUMNS_WITH_FS_TYPE.to_vec(),
+            ..Default::default()
+        };
+        let row = Row {
+            file: Some("/path/to/file".to_string()),
+            fs_device: "my_device".to_string(),
+            fs_type: "my_type".to_string(),
+            fs_mount: "my_mount".to_string(),
+
+            bytes: 4000,
+            bytes_used: 1000,
+            bytes_avail: 3000,
+            bytes_usage: Some(0.25),
+
+            #[cfg(target_os = "macos")]
+            bytes_capacity: Some(0.5),
+
+            inodes: 10,
+            inodes_used: 2,
+            inodes_free: 8,
+            inodes_usage: Some(0.2),
+        };
+        assert_eq!(
+            DisplayRow::new(&row, &options).to_string(),
+            "my_device        my_type         4.0k         1.0k         3.0k   25% my_mount        "
+        );
+    }
+
+    #[test]
+    fn test_row_display_human_readable_binary() {
+        let options = Options {
+            block_size: BlockSize::HumanReadableBinary,
+            columns: COLUMNS_WITH_FS_TYPE.to_vec(),
+            ..Default::default()
+        };
+        let row = Row {
+            file: Some("/path/to/file".to_string()),
+            fs_device: "my_device".to_string(),
+            fs_type: "my_type".to_string(),
+            fs_mount: "my_mount".to_string(),
+
+            bytes: 4096,
+            bytes_used: 1024,
+            bytes_avail: 3072,
+            bytes_usage: Some(0.25),
+
+            #[cfg(target_os = "macos")]
+            bytes_capacity: Some(0.5),
+
+            inodes: 10,
+            inodes_used: 2,
+            inodes_free: 8,
+            inodes_usage: Some(0.2),
+        };
+        assert_eq!(
+            DisplayRow::new(&row, &options).to_string(),
+            "my_device        my_type        4.0Ki        1.0Ki        3.0Ki   25% my_mount        "
+        );
+    }
+
+    #[test]
+    fn test_row_display_round_up_usage() {
+        let options = Options {
+            block_size: BlockSize::Bytes(1),
+            ..Default::default()
+        };
+        let row = Row {
+            file: Some("/path/to/file".to_string()),
+            fs_device: "my_device".to_string(),
+            fs_type: "my_type".to_string(),
+            fs_mount: "my_mount".to_string(),
+
+            bytes: 100,
+            bytes_used: 25,
+            bytes_avail: 75,
+            bytes_usage: Some(0.251),
+
+            #[cfg(target_os = "macos")]
+            bytes_capacity: Some(0.5),
+
+            inodes: 10,
+            inodes_used: 2,
+            inodes_free: 8,
+            inodes_usage: Some(0.2),
+        };
+        assert_eq!(
+            DisplayRow::new(&row, &options).to_string(),
+            "my_device                 100           25           75   26% my_mount        "
+        );
+    }
+}
diff --git a/src/uu/dircolors/Cargo.toml b/src/uu/dircolors/Cargo.toml
index 0bf53d91a..533793b63 100644
--- a/src/uu/dircolors/Cargo.toml
+++ b/src/uu/dircolors/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_dircolors"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dircolors ~ (uutils) display commands to set LS_COLORS"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/dircolors"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/dircolors"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,10 @@ edition = "2018"
 path = "src/dircolors.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 glob = "0.3.0"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "dircolors"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/dircolors/LICENSE b/src/uu/dircolors/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/dircolors/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/dircolors/src/dircolors.rs b/src/uu/dircolors/src/dircolors.rs
index 5d0b3ac3e..c76dbc0c1 100644
--- a/src/uu/dircolors/src/dircolors.rs
+++ b/src/uu/dircolors/src/dircolors.rs
@@ -8,16 +8,14 @@
 
 // spell-checker:ignore (ToDO) clrtoeol dircolors eightbit endcode fnmatch leftcode multihardlink rightcode setenv sgid suid
 
-#[macro_use]
-extern crate uucore;
-
 use std::borrow::Borrow;
 use std::env;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use uucore::display::Quotable;
+use uucore::error::{UResult, USimpleError, UUsageError};
 
 mod options {
     pub const BOURNE_SHELL: &str = "bourne-shell";
@@ -26,7 +24,7 @@ mod options {
     pub const FILE: &str = "FILE";
 }
 
-static SYNTAX: &str = "[OPTION]... [FILE]";
+static USAGE: &str = "{} [OPTION]... [FILE]";
 static SUMMARY: &str = "Output commands to set the LS_COLORS environment variable.";
 static LONG_HELP: &str = "
  If FILE is specified, read it to determine which colors to use for which
@@ -63,18 +61,13 @@ pub fn guess_syntax() -> OutputFmt {
     }
 }
 
-fn usage() -> String {
-    format!("{0} {1}", uucore::execution_phrase(), SYNTAX)
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(&args);
+    let matches = uu_app().get_matches_from(&args);
 
     let files = matches
         .values_of(options::FILE)
@@ -85,24 +78,26 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     if (matches.is_present(options::C_SHELL) || matches.is_present(options::BOURNE_SHELL))
         && matches.is_present(options::PRINT_DATABASE)
     {
-        show_usage_error!(
+        return Err(UUsageError::new(
+            1,
             "the options to output dircolors' internal database and\nto select a shell \
-             syntax are mutually exclusive"
-        );
-        return 1;
+             syntax are mutually exclusive",
+        ));
     }
 
     if matches.is_present(options::PRINT_DATABASE) {
         if !files.is_empty() {
-            show_usage_error!(
-                "extra operand {}\nfile operands cannot be combined with \
-                 --print-database (-p)",
-                files[0].quote()
-            );
-            return 1;
+            return Err(UUsageError::new(
+                1,
+                format!(
+                    "extra operand {}\nfile operands cannot be combined with \
+                     --print-database (-p)",
+                    files[0].quote()
+                ),
+            ));
         }
         println!("{}", INTERNAL_DB);
-        return 0;
+        return Ok(());
     }
 
     let mut out_format = OutputFmt::Unknown;
@@ -115,8 +110,10 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     if out_format == OutputFmt::Unknown {
         match guess_syntax() {
             OutputFmt::Unknown => {
-                show_error!("no SHELL environment variable, and no shell type option given");
-                return 1;
+                return Err(USimpleError::new(
+                    1,
+                    "no SHELL environment variable, and no shell type option given",
+                ));
             }
             fmt => out_format = fmt,
         }
@@ -124,64 +121,74 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     let result;
     if files.is_empty() {
-        result = parse(INTERNAL_DB.lines(), out_format, "")
+        result = parse(INTERNAL_DB.lines(), &out_format, "");
     } else {
         if files.len() > 1 {
-            show_usage_error!("extra operand {}", files[1].quote());
-            return 1;
+            return Err(UUsageError::new(
+                1,
+                format!("extra operand {}", files[1].quote()),
+            ));
         }
         match File::open(files[0]) {
             Ok(f) => {
                 let fin = BufReader::new(f);
-                result = parse(fin.lines().filter_map(Result::ok), out_format, files[0])
+                result = parse(fin.lines().filter_map(Result::ok), &out_format, files[0]);
             }
             Err(e) => {
-                show_error!("{}: {}", files[0].maybe_quote(), e);
-                return 1;
+                return Err(USimpleError::new(
+                    1,
+                    format!("{}: {}", files[0].maybe_quote(), e),
+                ));
             }
         }
     }
+
     match result {
         Ok(s) => {
             println!("{}", s);
-            0
+            Ok(())
         }
         Err(s) => {
-            show_error!("{}", s);
-            1
+            return Err(USimpleError::new(1, s));
         }
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(SUMMARY)
         .after_help(LONG_HELP)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BOURNE_SHELL)
+            Arg::new(options::BOURNE_SHELL)
                 .long("sh")
-                .short("b")
+                .short('b')
                 .visible_alias("bourne-shell")
                 .help("output Bourne shell code to set LS_COLORS")
                 .display_order(1),
         )
         .arg(
-            Arg::with_name(options::C_SHELL)
+            Arg::new(options::C_SHELL)
                 .long("csh")
-                .short("c")
+                .short('c')
                 .visible_alias("c-shell")
                 .help("output C shell code to set LS_COLORS")
                 .display_order(2),
         )
         .arg(
-            Arg::with_name(options::PRINT_DATABASE)
+            Arg::new(options::PRINT_DATABASE)
                 .long("print-database")
-                .short("p")
+                .short('p')
                 .help("print the byte counts")
                 .display_order(3),
         )
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .arg(
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
 }
 
 pub trait StrUtils {
@@ -245,9 +252,9 @@ enum ParseState {
     Pass,
 }
 use std::collections::HashMap;
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
-fn parse<T>(lines: T, fmt: OutputFmt, fp: &str) -> Result<String, String>
+fn parse<T>(lines: T, fmt: &OutputFmt, fp: &str) -> Result<String, String>
 where
     T: IntoIterator,
     T::Item: Borrow<str>,
diff --git a/src/uu/dircolors/src/main.rs b/src/uu/dircolors/src/main.rs
index a6a820bd9..f8c8d4ea5 100644
--- a/src/uu/dircolors/src/main.rs
+++ b/src/uu/dircolors/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_dircolors);
+uucore::bin!(uu_dircolors);
diff --git a/src/uu/dirname/Cargo.toml b/src/uu/dirname/Cargo.toml
index 7946459f3..cede0c6b1 100644
--- a/src/uu/dirname/Cargo.toml
+++ b/src/uu/dirname/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_dirname"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "dirname ~ (uutils) display parent directory of PATHNAME"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/dirname"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/dirname"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,8 @@ edition = "2018"
 path = "src/dirname.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "dirname"
diff --git a/src/uu/dirname/LICENSE b/src/uu/dirname/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/dirname/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/dirname/src/dirname.rs b/src/uu/dirname/src/dirname.rs
index 129c9369e..030c3981c 100644
--- a/src/uu/dirname/src/dirname.rs
+++ b/src/uu/dirname/src/dirname.rs
@@ -5,23 +5,20 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::path::Path;
 use uucore::display::print_verbatim;
 use uucore::error::{UResult, UUsageError};
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "strip last component from file name";
+const USAGE: &str = "{} [OPTION] NAME...";
 
 mod options {
     pub const ZERO: &str = "zero";
     pub const DIR: &str = "dir";
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION] NAME...", uucore::execution_phrase())
-}
-
 fn get_long_usage() -> String {
     String::from(
         "Output each NAME with its last non-slash component and trailing slashes
@@ -29,19 +26,15 @@ fn get_long_usage() -> String {
     )
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
 
-    let usage = usage();
     let after_help = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let separator = if matches.is_present(options::ZERO) {
         "\0"
@@ -56,12 +49,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .collect();
 
     if !dirnames.is_empty() {
-        for path in dirnames.iter() {
+        for path in &dirnames {
             let p = Path::new(path);
             match p.parent() {
                 Some(d) => {
                     if d.components().next() == None {
-                        print!(".")
+                        print!(".");
                     } else {
                         print_verbatim(d).unwrap();
                     }
@@ -83,15 +76,17 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .about(ABOUT)
         .version(crate_version!())
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::ZERO)
+            Arg::new(options::ZERO)
                 .long(options::ZERO)
-                .short("z")
+                .short('z')
                 .help("separate output with NUL rather than newline"),
         )
-        .arg(Arg::with_name(options::DIR).hidden(true).multiple(true))
+        .arg(Arg::new(options::DIR).hide(true).multiple_occurrences(true))
 }
diff --git a/src/uu/dirname/src/main.rs b/src/uu/dirname/src/main.rs
index bf923e86a..aa4891134 100644
--- a/src/uu/dirname/src/main.rs
+++ b/src/uu/dirname/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_dirname);
+uucore::bin!(uu_dirname);
diff --git a/src/uu/du/Cargo.toml b/src/uu/du/Cargo.toml
index c9da0462c..c0c64f2e7 100644
--- a/src/uu/du/Cargo.toml
+++ b/src/uu/du/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_du"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "du ~ (uutils) display disk usage"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/du"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/du"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/du.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-chrono = "0.4"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+chrono = "^0.4.11"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version="0.3", features=[] }
diff --git a/src/uu/du/LICENSE b/src/uu/du/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/du/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index 9fd44b001..0690c6299 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -10,15 +10,13 @@ extern crate uucore;
 
 use chrono::prelude::DateTime;
 use chrono::Local;
-use clap::ArgMatches;
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use std::collections::HashSet;
-use std::convert::TryFrom;
 use std::env;
 use std::fs;
 #[cfg(not(windows))]
 use std::fs::Metadata;
-use std::io::{stderr, ErrorKind, Result, Write};
+use std::io::{ErrorKind, Result};
 use std::iter;
 #[cfg(not(windows))]
 use std::os::unix::fs::MetadataExt;
@@ -34,6 +32,7 @@ use std::time::{Duration, UNIX_EPOCH};
 use std::{error::Error, fmt::Display};
 use uucore::display::{print_verbatim, Quotable};
 use uucore::error::{UError, UResult};
+use uucore::format_usage;
 use uucore::parse_size::{parse_size, ParseSizeError};
 use uucore::InvalidEncodingHandling;
 #[cfg(windows)]
@@ -48,6 +47,7 @@ use winapi::um::winbase::GetFileInformationByHandleEx;
 use winapi::um::winnt::{FILE_ID_128, ULONGLONG};
 
 mod options {
+    pub const HELP: &str = "help";
     pub const NULL: &str = "0";
     pub const ALL: &str = "all";
     pub const APPARENT_SIZE: &str = "apparent-size";
@@ -81,6 +81,9 @@ SIZE is an integer and optional unit (example: 10M is 10*1024*1024).
 Units are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB,... (powers
 of 1000).
 ";
+const USAGE: &str = "\
+    {} [OPTION]... [FILE]...
+    {} [OPTION]... --files0-from=F";
 
 // 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)];
@@ -115,7 +118,7 @@ struct Stat {
 }
 
 impl Stat {
-    fn new(path: PathBuf, options: &Options) -> Result<Stat> {
+    fn new(path: PathBuf, options: &Options) -> Result<Self> {
         let metadata = if options.dereference {
             fs::metadata(&path)?
         } else {
@@ -128,7 +131,7 @@ impl Stat {
             dev_id: metadata.dev(),
         };
         #[cfg(not(windows))]
-        return Ok(Stat {
+        return Ok(Self {
             path,
             is_dir: metadata.is_dir(),
             size: metadata.len(),
@@ -145,7 +148,7 @@ impl Stat {
         #[cfg(windows)]
         let file_info = get_file_info(&path);
         #[cfg(windows)]
-        Ok(Stat {
+        Ok(Self {
             path,
             is_dir: metadata.is_dir(),
             size: metadata.len(),
@@ -245,10 +248,10 @@ fn get_file_info(path: &Path) -> Option<FileInfo> {
     result
 }
 
-fn read_block_size(s: Option<&str>) -> usize {
+fn read_block_size(s: Option<&str>) -> u64 {
     if let Some(s) = s {
         parse_size(s)
-            .unwrap_or_else(|e| crash!(1, "{}", format_error_message(e, s, options::BLOCK_SIZE)))
+            .unwrap_or_else(|e| crash!(1, "{}", format_error_message(&e, s, options::BLOCK_SIZE)))
     } else {
         for env_var in &["DU_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"] {
             if let Ok(env_size) = env::var(env_var) {
@@ -292,8 +295,7 @@ fn du(
         let read = match fs::read_dir(&my_stat.path) {
             Ok(read) => read,
             Err(e) => {
-                safe_writeln!(
-                    stderr(),
+                eprintln!(
                     "{}: cannot read directory {}: {}",
                     options.util_name,
                     my_stat.path.quote(),
@@ -337,7 +339,7 @@ fn du(
                         ErrorKind::PermissionDenied => {
                             let description = format!("cannot access {}", entry.path().quote());
                             let error_message = "Permission denied";
-                            show_error_custom_description!(description, "{}", error_message)
+                            show_error_custom_description!(description, "{}", error_message);
                         }
                         _ => show_error!("cannot access {}: {}", entry.path().quote(), error),
                     },
@@ -393,14 +395,6 @@ fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
     format!("{}", ((size as f64) / (block_size as f64)).ceil())
 }
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [FILE]...
-    {0} [OPTION]... --files0-from=F",
-        uucore::execution_phrase()
-    )
-}
-
 #[derive(Debug)]
 enum DuError {
     InvalidMaxDepthArg(String),
@@ -446,24 +440,22 @@ impl Error for DuError {}
 impl UError for DuError {
     fn code(&self) -> i32 {
         match self {
-            Self::InvalidMaxDepthArg(_) => 1,
-            Self::SummarizeDepthConflict(_) => 1,
-            Self::InvalidTimeStyleArg(_) => 1,
-            Self::InvalidTimeArg(_) => 1,
+            Self::InvalidMaxDepthArg(_)
+            | Self::SummarizeDepthConflict(_)
+            | Self::InvalidTimeStyleArg(_)
+            | Self::InvalidTimeArg(_) => 1,
         }
     }
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 #[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     let summarize = matches.is_present(options::SUMMARIZE);
 
@@ -488,14 +480,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     if options.inodes
         && (matches.is_present(options::APPARENT_SIZE) || matches.is_present(options::BYTES))
     {
-        show_warning!("options --apparent-size and -b are ineffective with --inodes")
+        show_warning!("options --apparent-size and -b are ineffective with --inodes");
     }
 
-    let block_size = u64::try_from(read_block_size(matches.value_of(options::BLOCK_SIZE))).unwrap();
+    let block_size = read_block_size(matches.value_of(options::BLOCK_SIZE));
 
     let threshold = matches.value_of(options::THRESHOLD).map(|s| {
         Threshold::from_str(s)
-            .unwrap_or_else(|e| crash!(1, "{}", format_error_message(e, s, options::THRESHOLD)))
+            .unwrap_or_else(|e| crash!(1, "{}", format_error_message(&e, s, options::THRESHOLD)))
     });
 
     let multiplier: u64 = if matches.is_present(options::SI) {
@@ -626,30 +618,36 @@ fn parse_depth(max_depth_str: Option<&str>, summarize: bool) -> UResult<Option<u
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(SUMMARY)
         .after_help(LONG_HELP)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::ALL)
-                .short("a")
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information.")
+        )
+        .arg(
+            Arg::new(options::ALL)
+                .short('a')
                 .long(options::ALL)
                 .help("write counts for all files, not just directories"),
         )
         .arg(
-            Arg::with_name(options::APPARENT_SIZE)
+            Arg::new(options::APPARENT_SIZE)
                 .long(options::APPARENT_SIZE)
                 .help(
                     "print apparent sizes,  rather  than  disk  usage \
                     although  the apparent  size is usually smaller, it may be larger due to holes \
                     in ('sparse') files, internal  fragmentation,  indirect  blocks, and the like"
                 )
-                .alias("app") // The GNU test suite uses this alias
         )
         .arg(
-            Arg::with_name(options::BLOCK_SIZE)
-                .short("B")
+            Arg::new(options::BLOCK_SIZE)
+                .short('B')
                 .long(options::BLOCK_SIZE)
                 .value_name("SIZE")
                 .help(
@@ -658,20 +656,20 @@ pub fn uu_app() -> App<'static, 'static> {
                 )
         )
         .arg(
-            Arg::with_name(options::BYTES)
-                .short("b")
+            Arg::new(options::BYTES)
+                .short('b')
                 .long("bytes")
                 .help("equivalent to '--apparent-size --block-size=1'")
         )
         .arg(
-            Arg::with_name(options::TOTAL)
+            Arg::new(options::TOTAL)
                 .long("total")
-                .short("c")
+                .short('c')
                 .help("produce a grand total")
         )
         .arg(
-            Arg::with_name(options::MAX_DEPTH)
-                .short("d")
+            Arg::new(options::MAX_DEPTH)
+                .short('d')
                 .long("max-depth")
                 .value_name("N")
                 .help(
@@ -681,80 +679,79 @@ pub fn uu_app() -> App<'static, 'static> {
                 )
         )
         .arg(
-            Arg::with_name(options::HUMAN_READABLE)
+            Arg::new(options::HUMAN_READABLE)
                 .long("human-readable")
-                .short("h")
+                .short('h')
                 .help("print sizes in human readable format (e.g., 1K 234M 2G)")
         )
         .arg(
-            Arg::with_name(options::INODES)
+            Arg::new(options::INODES)
                 .long(options::INODES)
                 .help(
                     "list inode usage information instead of block usage like --block-size=1K"
                 )
         )
         .arg(
-            Arg::with_name(options::BLOCK_SIZE_1K)
-                .short("k")
+            Arg::new(options::BLOCK_SIZE_1K)
+                .short('k')
                 .help("like --block-size=1K")
         )
         .arg(
-            Arg::with_name(options::COUNT_LINKS)
-                .short("l")
+            Arg::new(options::COUNT_LINKS)
+                .short('l')
                 .long("count-links")
                 .help("count sizes many times if hard linked")
         )
         .arg(
-            Arg::with_name(options::DEREFERENCE)
-                .short("L")
+            Arg::new(options::DEREFERENCE)
+                .short('L')
                 .long(options::DEREFERENCE)
                 .help("dereference all symbolic links")
         )
         // .arg(
-        //     Arg::with_name("no-dereference")
-        //         .short("P")
+        //     Arg::new("no-dereference")
+        //         .short('P')
         //         .long("no-dereference")
         //         .help("don't follow any symbolic links (this is the default)")
         // )
         .arg(
-            Arg::with_name(options::BLOCK_SIZE_1M)
-                .short("m")
+            Arg::new(options::BLOCK_SIZE_1M)
+                .short('m')
                 .help("like --block-size=1M")
         )
         .arg(
-            Arg::with_name(options::NULL)
-                .short("0")
+            Arg::new(options::NULL)
+                .short('0')
                 .long("null")
                 .help("end each output line with 0 byte rather than newline")
         )
         .arg(
-            Arg::with_name(options::SEPARATE_DIRS)
-                .short("S")
+            Arg::new(options::SEPARATE_DIRS)
+                .short('S')
                 .long("separate-dirs")
                 .help("do not include size of subdirectories")
         )
         .arg(
-            Arg::with_name(options::SUMMARIZE)
-                .short("s")
+            Arg::new(options::SUMMARIZE)
+                .short('s')
                 .long("summarize")
                 .help("display only a total for each argument")
         )
         .arg(
-            Arg::with_name(options::SI)
+            Arg::new(options::SI)
                 .long(options::SI)
                 .help("like -h, but use powers of 1000 not 1024")
         )
         .arg(
-            Arg::with_name(options::ONE_FILE_SYSTEM)
-                .short("x")
+            Arg::new(options::ONE_FILE_SYSTEM)
+                .short('x')
                 .long(options::ONE_FILE_SYSTEM)
                 .help("skip directories on different file systems")
         )
         .arg(
-            Arg::with_name(options::THRESHOLD)
-                .short("t")
+            Arg::new(options::THRESHOLD)
+                .short('t')
                 .long(options::THRESHOLD)
-                .alias("th")
                 .value_name("SIZE")
                 .number_of_values(1)
                 .allow_hyphen_values(true)
@@ -762,20 +759,20 @@ pub fn uu_app() -> App<'static, 'static> {
                           or entries greater than SIZE if negative")
         )
         // .arg(
-        //     Arg::with_name("")
-        //         .short("x")
+        //     Arg::new("")
+        //         .short('x')
         //         .long("exclude-from")
         //         .value_name("FILE")
         //         .help("exclude files that match any pattern in FILE")
         // )
         // .arg(
-        //     Arg::with_name("exclude")
+        //     Arg::new("exclude")
         //         .long("exclude")
         //         .value_name("PATTERN")
         //         .help("exclude files that match PATTERN")
         // )
         .arg(
-            Arg::with_name(options::TIME)
+            Arg::new(options::TIME)
                 .long(options::TIME)
                 .value_name("WORD")
                 .require_equals(true)
@@ -788,7 +785,7 @@ pub fn uu_app() -> App<'static, 'static> {
                 )
         )
         .arg(
-            Arg::with_name(options::TIME_STYLE)
+            Arg::new(options::TIME_STYLE)
                 .long(options::TIME_STYLE)
                 .value_name("STYLE")
                 .help(
@@ -797,9 +794,9 @@ pub fn uu_app() -> App<'static, 'static> {
                 )
         )
         .arg(
-            Arg::with_name(options::FILE)
-                .hidden(true)
-                .multiple(true)
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true)
         )
 }
 
@@ -815,12 +812,12 @@ impl FromStr for Threshold {
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
         let offset = if s.starts_with(&['-', '+'][..]) { 1 } else { 0 };
 
-        let size = u64::try_from(parse_size(&s[offset..])?).unwrap();
+        let size = parse_size(&s[offset..])?;
 
         if s.starts_with('-') {
-            Ok(Threshold::Upper(size))
+            Ok(Self::Upper(size))
         } else {
-            Ok(Threshold::Lower(size))
+            Ok(Self::Lower(size))
         }
     }
 }
@@ -828,13 +825,13 @@ impl FromStr for Threshold {
 impl Threshold {
     fn should_exclude(&self, size: u64) -> bool {
         match *self {
-            Threshold::Upper(threshold) => size > threshold,
-            Threshold::Lower(threshold) => size < threshold,
+            Self::Upper(threshold) => size > threshold,
+            Self::Lower(threshold) => size < threshold,
         }
     }
 }
 
-fn format_error_message(error: ParseSizeError, s: &str, option: &str) -> String {
+fn format_error_message(error: &ParseSizeError, s: &str, option: &str) -> String {
     // NOTE:
     // GNU's du echos affected flag, -B or --block-size (-t or --threshold), depending user's selection
     // GNU's du does distinguish between "invalid (suffix in) argument"
@@ -856,7 +853,7 @@ mod test_du {
             (Some("K".to_string()), 1024),
             (None, 1024),
         ];
-        for it in test_data.iter() {
+        for it in &test_data {
             assert_eq!(read_block_size(it.0.as_deref()), it.1);
         }
     }
diff --git a/src/uu/du/src/main.rs b/src/uu/du/src/main.rs
index de9bfc1a5..3d00ad9b5 100644
--- a/src/uu/du/src/main.rs
+++ b/src/uu/du/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_du);
+uucore::bin!(uu_du);
diff --git a/src/uu/echo/Cargo.toml b/src/uu/echo/Cargo.toml
index 05dd1eba1..9fde0ce35 100644
--- a/src/uu/echo/Cargo.toml
+++ b/src/uu/echo/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_echo"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "echo ~ (uutils) display TEXT"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/echo"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/echo"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/echo.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "echo"
diff --git a/src/uu/echo/LICENSE b/src/uu/echo/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/echo/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/echo/src/echo.rs b/src/uu/echo/src/echo.rs
index a0e6c0d9c..d2de30cb1 100644
--- a/src/uu/echo/src/echo.rs
+++ b/src/uu/echo/src/echo.rs
@@ -6,16 +6,16 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::io::{self, Write};
 use std::iter::Peekable;
 use std::str::Chars;
 use uucore::error::{FromIo, UResult};
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 const NAME: &str = "echo";
 const SUMMARY: &str = "display a line of text";
-const USAGE: &str = "[OPTIONS]... [STRING]...";
+const USAGE: &str = "{} [OPTIONS]... [STRING]...";
 const AFTER_HELP: &str = r#"
  Echo the STRING(s) to standard output.
 
@@ -88,10 +88,7 @@ fn print_escaped(input: &str, mut output: impl Write) -> io::Result<bool> {
                         start = 0;
                         next
                     }),
-                    '0' => parse_code(&mut iter, 8, 3, 3).unwrap_or_else(|| {
-                        start = 0;
-                        next
-                    }),
+                    '0' => parse_code(&mut iter, 8, 3, 3).unwrap_or('\0'),
                     _ => {
                         start = 0;
                         next
@@ -111,7 +108,7 @@ fn print_escaped(input: &str, mut output: impl Write) -> io::Result<bool> {
     Ok(should_stop)
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
@@ -125,50 +122,45 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         None => vec!["".to_string()],
     };
 
-    execute(no_newline, escaped, values).map_err_context(|| "could not write to stdout".to_string())
+    execute(no_newline, escaped, &values)
+        .map_err_context(|| "could not write to stdout".to_string())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         // TrailingVarArg specifies the final positional argument is a VarArg
         // and it doesn't attempts the parse any further args.
         // Final argument must have multiple(true) or the usage string equivalent.
-        .setting(clap::AppSettings::TrailingVarArg)
-        .setting(clap::AppSettings::AllowLeadingHyphen)
+        .trailing_var_arg(true)
+        .allow_hyphen_values(true)
+        .infer_long_args(true)
         .version(crate_version!())
         .about(SUMMARY)
         .after_help(AFTER_HELP)
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .arg(
-            Arg::with_name(options::NO_NEWLINE)
-                .short("n")
+            Arg::new(options::NO_NEWLINE)
+                .short('n')
                 .help("do not output the trailing newline")
-                .takes_value(false)
-                .display_order(1),
+                .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::ENABLE_BACKSLASH_ESCAPE)
-                .short("e")
+            Arg::new(options::ENABLE_BACKSLASH_ESCAPE)
+                .short('e')
                 .help("enable interpretation of backslash escapes")
-                .takes_value(false)
-                .display_order(2),
+                .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::DISABLE_BACKSLASH_ESCAPE)
-                .short("E")
+            Arg::new(options::DISABLE_BACKSLASH_ESCAPE)
+                .short('E')
                 .help("disable interpretation of backslash escapes (default)")
-                .takes_value(false)
-                .display_order(3),
-        )
-        .arg(
-            Arg::with_name(options::STRING)
-                .multiple(true)
-                .allow_hyphen_values(true),
+                .takes_value(false),
         )
+        .arg(Arg::new(options::STRING).multiple_occurrences(true))
 }
 
-fn execute(no_newline: bool, escaped: bool, free: Vec<String>) -> io::Result<()> {
+fn execute(no_newline: bool, escaped: bool, free: &[String]) -> io::Result<()> {
     let stdout = io::stdout();
     let mut output = stdout.lock();
 
diff --git a/src/uu/echo/src/main.rs b/src/uu/echo/src/main.rs
index b8d3b4b32..85747c448 100644
--- a/src/uu/echo/src/main.rs
+++ b/src/uu/echo/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_echo);
+uucore::bin!(uu_echo);
diff --git a/src/uu/env/Cargo.toml b/src/uu/env/Cargo.toml
index 374a4eda9..ae30458a0 100644
--- a/src/uu/env/Cargo.toml
+++ b/src/uu/env/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_env"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "env ~ (uutils) set each NAME to VALUE in the environment and run COMMAND"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/env"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/env"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,9 @@ edition = "2018"
 path = "src/env.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 rust-ini = "0.17.0"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["signals"]}
 
 [[bin]]
 name = "env"
diff --git a/src/uu/env/LICENSE b/src/uu/env/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/env/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/env/src/env.rs b/src/uu/env/src/env.rs
index aec97fc24..2ec0ce1c6 100644
--- a/src/uu/env/src/env.rs
+++ b/src/uu/env/src/env.rs
@@ -1,13 +1,14 @@
 // This file is part of the uutils coreutils package.
 //
 // (c) Jordi Boggiano <j.boggiano@seld.be>
+// (c) Thomas Queiroz <thomasqueirozb@gmail.com>
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
 /* last synced with: env (GNU coreutils) 8.13 */
 
-// spell-checker:ignore (ToDO) chdir execvp progname subcommand subcommands unsets
+// spell-checker:ignore (ToDO) chdir execvp progname subcommand subcommands unsets setenv putenv spawnp
 
 #[macro_use]
 extern crate clap;
@@ -15,17 +16,22 @@ extern crate clap;
 #[macro_use]
 extern crate uucore;
 
-use clap::{App, AppSettings, Arg};
+use clap::{Arg, Command};
 use ini::Ini;
 use std::borrow::Cow;
 use std::env;
 use std::io::{self, Write};
 use std::iter::Iterator;
-use std::process::Command;
+#[cfg(unix)]
+use std::os::unix::process::ExitStatusExt;
+use std::process;
 use uucore::display::Quotable;
-use uucore::error::{UResult, USimpleError};
+use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::format_usage;
+#[cfg(unix)]
+use uucore::signals::signal_name_by_value;
 
-const USAGE: &str = "env [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]";
+const USAGE: &str = "{} [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]";
 const AFTER_HELP: &str = "\
 A mere - implies -i. If no COMMAND, print the resulting environment.
 ";
@@ -50,7 +56,7 @@ fn print_env(null: bool) {
     }
 }
 
-fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> Result<bool, i32> {
+fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<bool> {
     // is it a NAME=VALUE like opt ?
     if let Some(idx) = opt.find('=') {
         // yes, so push name, value pair
@@ -64,17 +70,12 @@ fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> Result<bool
     }
 }
 
-fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> Result<(), i32> {
+fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<()> {
     if opts.null {
-        eprintln!(
-            "{}: cannot specify --null (-0) with command",
-            uucore::util_name()
-        );
-        eprintln!(
-            "Type \"{} --help\" for detailed information",
-            uucore::execution_phrase()
-        );
-        Err(1)
+        Err(UUsageError::new(
+            125,
+            "cannot specify --null (-0) with command".to_string(),
+        ))
     } else {
         opts.program.push(opt);
         Ok(())
@@ -93,10 +94,8 @@ fn load_config_file(opts: &mut Options) -> UResult<()> {
             Ini::load_from_file(file)
         };
 
-        let conf = conf.map_err(|error| {
-            show_error!("{}: {}", file.maybe_quote(), error);
-            1
-        })?;
+        let conf =
+            conf.map_err(|e| USimpleError::new(1, format!("{}: {}", file.maybe_quote(), e)))?;
 
         for (_, prop) in &conf {
             // ignore all INI section lines (treat them as comments)
@@ -110,6 +109,7 @@ fn load_config_file(opts: &mut Options) -> UResult<()> {
 }
 
 #[cfg(not(windows))]
+#[allow(clippy::ptr_arg)]
 fn build_command<'a, 'b>(args: &'a mut Vec<&'b str>) -> (Cow<'b, str>, &'a [&'b str]) {
     let progname = Cow::from(args[0]);
     (progname, &args[1..])
@@ -125,46 +125,47 @@ fn build_command<'a, 'b>(args: &'a mut Vec<&'b str>) -> (Cow<'b, str>, &'a [&'b
     (progname, &args[..])
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(crate_name!())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(crate_name!())
         .version(crate_version!())
         .author(crate_authors!())
         .about(crate_description!())
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
-        .setting(AppSettings::AllowExternalSubcommands)
-        .arg(Arg::with_name("ignore-environment")
-            .short("i")
+        .allow_external_subcommands(true)
+        .infer_long_args(true)
+        .arg(Arg::new("ignore-environment")
+            .short('i')
             .long("ignore-environment")
             .help("start with an empty environment"))
-        .arg(Arg::with_name("chdir")
-            .short("c")
+        .arg(Arg::new("chdir")
+            .short('C') // GNU env compatibility
             .long("chdir")
             .takes_value(true)
             .number_of_values(1)
             .value_name("DIR")
             .help("change working directory to DIR"))
-        .arg(Arg::with_name("null")
-            .short("0")
+        .arg(Arg::new("null")
+            .short('0')
             .long("null")
             .help("end each output line with a 0 byte rather than a newline (only valid when \
                     printing the environment)"))
-        .arg(Arg::with_name("file")
-            .short("f")
+        .arg(Arg::new("file")
+            .short('f')
             .long("file")
             .takes_value(true)
             .number_of_values(1)
             .value_name("PATH")
-            .multiple(true)
+            .multiple_occurrences(true)
             .help("read and set variables from a \".env\"-style configuration file (prior to any \
                     unset and/or set)"))
-        .arg(Arg::with_name("unset")
-            .short("u")
+        .arg(Arg::new("unset")
+            .short('u')
             .long("unset")
             .takes_value(true)
             .number_of_values(1)
             .value_name("NAME")
-            .multiple(true)
+            .multiple_occurrences(true)
             .help("remove variable from the environment"))
 }
 
@@ -209,7 +210,7 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
 
     // we handle the name, value pairs and the program to be executed by treating them as external
     // subcommands in clap
-    if let (external, Some(matches)) = matches.subcommand() {
+    if let Some((external, matches)) = matches.subcommand() {
         let mut begin_prog_opts = false;
 
         if external == "-" {
@@ -236,6 +237,14 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
         }
     }
 
+    // GNU env tests this behavior
+    if opts.program.is_empty() && running_directory.is_some() {
+        return Err(UUsageError::new(
+            125,
+            "must specify command with --chdir (-C)".to_string(),
+        ));
+    }
+
     // NOTE: we manually set and unset the env vars below rather than using Command::env() to more
     //       easily handle the case where no command is given
 
@@ -251,12 +260,44 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
 
     // unset specified env vars
     for name in &opts.unsets {
+        if name.is_empty() || name.contains(0 as char) || name.contains('=') {
+            return Err(USimpleError::new(
+                125,
+                format!("cannot unset {}: Invalid argument", name.quote()),
+            ));
+        }
+
         env::remove_var(name);
     }
 
     // set specified env vars
     for &(name, val) in &opts.sets {
-        // FIXME: set_var() panics if name is an empty string
+        /*
+         * set_var panics if name is an empty string
+         * set_var internally calls setenv (on unix at least), while GNU env calls putenv instead.
+         *
+         * putenv returns successfully if provided with something like "=a" and modifies the environ
+         * variable to contain "=a" inside it, effectively modifying the process' current environment
+         * to contain a malformed string in it. Using GNU's implementation, the command `env =a`
+         * prints out the malformed string and even invokes the child process with that environment.
+         * This can be seen by using `env -i =a env` or `env -i =a cat /proc/self/environ`
+         *
+         * POSIX.1-2017 doesn't seem to mention what to do if the string is malformed (at least
+         * not in "Chapter 8, Environment Variables" or in the definition for environ and various
+         * exec*'s or in the description of env in the "Shell & Utilities" volume).
+         *
+         * It also doesn't specify any checks for putenv before modifying the environ variable, which
+         * is likely why glibc doesn't do so. However, the first set_var argument cannot point to
+         * an empty string or a string containing '='.
+         *
+         * There is no benefit in replicating GNU's env behavior, since it will only modify the
+         * environment in weird ways
+         */
+
+        if name.is_empty() {
+            show_warning!("no name specified for value {}", val.quote());
+            continue;
+        }
         env::set_var(name, val);
     }
 
@@ -264,9 +305,44 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
         // we need to execute a command
         let (prog, args) = build_command(&mut opts.program);
 
-        // FIXME: this should just use execvp() (no fork()) on Unix-like systems
-        match Command::new(&*prog).args(args).status() {
-            Ok(exit) if !exit.success() => return Err(exit.code().unwrap().into()),
+        /*
+         * On Unix-like systems Command::status either ends up calling either fork or posix_spawnp
+         * (which ends up calling clone). Keep using the current process would be ideal, but the
+         * standard library contains many checks and fail-safes to ensure the process ends up being
+         * created. This is much simpler than dealing with the hassles of calling execvp directly.
+         */
+        match process::Command::new(&*prog).args(args).status() {
+            Ok(exit) if !exit.success() => {
+                #[cfg(unix)]
+                if let Some(exit_code) = exit.code() {
+                    return Err(exit_code.into());
+                } else {
+                    // `exit.code()` returns `None` on Unix when the process is terminated by a signal.
+                    // See std::os::unix::process::ExitStatusExt for more information. This prints out
+                    // the interrupted process and the signal it received.
+                    let signal_code = exit.signal().unwrap();
+                    eprintln!(
+                        "\"{}\" terminated by signal {}",
+                        {
+                            let mut command = uucore::util_name().to_owned();
+                            command.push(' ');
+                            command.push_str(&opts.program.join(" "));
+                            command
+                        },
+                        signal_name_by_value(signal_code as usize).map_or_else(
+                            || String::from("UNKNOWN"),
+                            |signal| {
+                                let mut full_signal_name = String::from("SIG");
+                                full_signal_name.push_str(signal);
+                                full_signal_name
+                            }
+                        )
+                    );
+                    return Err((128 + signal_code).into());
+                }
+                #[cfg(not(unix))]
+                return Err(exit.code().unwrap().into());
+            }
             Err(ref err) if err.kind() == io::ErrorKind::NotFound => return Err(127.into()),
             Err(_) => return Err(126.into()),
             Ok(_) => (),
@@ -279,7 +355,7 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     run_env(args)
 }
diff --git a/src/uu/env/src/main.rs b/src/uu/env/src/main.rs
index 9c19a3ab4..662167388 100644
--- a/src/uu/env/src/main.rs
+++ b/src/uu/env/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_env);
+uucore::bin!(uu_env);
diff --git a/src/uu/expand/Cargo.toml b/src/uu/expand/Cargo.toml
index efd338dab..aba67d6c7 100644
--- a/src/uu/expand/Cargo.toml
+++ b/src/uu/expand/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_expand"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "expand ~ (uutils) convert input tabs to spaces"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/expand"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/expand"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,10 @@ edition = "2018"
 path = "src/expand.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 unicode-width = "0.1.5"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "expand"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/expand/LICENSE b/src/uu/expand/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/expand/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/expand/src/expand.rs b/src/uu/expand/src/expand.rs
index b09b8aaab..b9d9309cd 100644
--- a/src/uu/expand/src/expand.rs
+++ b/src/uu/expand/src/expand.rs
@@ -12,15 +12,18 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use std::fs::File;
 use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
 use std::str::from_utf8;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
+use uucore::format_usage;
 
 static ABOUT: &str = "Convert tabs in each FILE to spaces, writing to standard output.
  With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
 pub mod options {
     pub static TABS: &str = "tabs";
@@ -33,10 +36,6 @@ static LONG_HELP: &str = "";
 
 static DEFAULT_TABSTOP: usize = 8;
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
-
 /// The mode to use when replacing tabs beyond the last one specified in
 /// the `--tabs` argument.
 enum RemainingMode {
@@ -66,7 +65,7 @@ fn is_space_or_comma(c: char) -> bool {
 /// in the list. This mode defines the strategy to use for computing the
 /// number of spaces to use for columns beyond the end of the tab stop
 /// list specified here.
-fn tabstops_parse(s: String) -> (RemainingMode, Vec<usize>) {
+fn tabstops_parse(s: &str) -> (RemainingMode, Vec<usize>) {
     // Leading commas and spaces are ignored.
     let s = s.trim_start_matches(is_space_or_comma);
 
@@ -132,9 +131,9 @@ struct Options {
 }
 
 impl Options {
-    fn new(matches: &ArgMatches) -> Options {
+    fn new(matches: &ArgMatches) -> Self {
         let (remaining_mode, tabstops) = match matches.value_of(options::TABS) {
-            Some(s) => tabstops_parse(s.to_string()),
+            Some(s) => tabstops_parse(s),
             None => (RemainingMode::None, vec![DEFAULT_TABSTOP]),
         };
 
@@ -159,7 +158,7 @@ impl Options {
             None => vec!["-".to_owned()],
         };
 
-        Options {
+        Self {
             files,
             tabstops,
             tspaces,
@@ -170,52 +169,53 @@ impl Options {
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
-    expand(Options::new(&matches));
-    0
+    expand(&Options::new(&matches)).map_err_context(|| "failed to write output".to_string())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::INITIAL)
+            Arg::new(options::INITIAL)
                 .long(options::INITIAL)
-                .short("i")
+                .short('i')
                 .help("do not convert tabs after non blanks"),
         )
         .arg(
-            Arg::with_name(options::TABS)
+            Arg::new(options::TABS)
                 .long(options::TABS)
-                .short("t")
+                .short('t')
                 .value_name("N, LIST")
                 .takes_value(true)
                 .help("have tabs N characters apart, not 8 or use comma separated list of explicit tab positions"),
         )
         .arg(
-            Arg::with_name(options::NO_UTF8)
+            Arg::new(options::NO_UTF8)
                 .long(options::NO_UTF8)
-                .short("U")
+                .short('U')
                 .help("interpret input file as 8-bit ASCII rather than UTF-8"),
         ).arg(
-            Arg::with_name(options::FILES)
-                .multiple(true)
-                .hidden(true)
+            Arg::new(options::FILES)
+                .multiple_occurrences(true)
+                .hide(true)
                 .takes_value(true)
         )
 }
 
-fn open(path: String) -> BufReader<Box<dyn Read + 'static>> {
+fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
     let file_buf;
     if path == "-" {
         BufReader::new(Box::new(stdin()) as Box<dyn Read>)
     } else {
-        file_buf = match File::open(&path[..]) {
+        file_buf = match File::open(path) {
             Ok(a) => a,
             Err(e) => crash!(1, "{}: {}\n", path.maybe_quote(), e),
         };
@@ -269,14 +269,14 @@ enum CharType {
     Other,
 }
 
-fn expand(options: Options) {
+fn expand(options: &Options) -> std::io::Result<()> {
     use self::CharType::*;
 
     let mut output = BufWriter::new(stdout());
     let ts = options.tabstops.as_ref();
     let mut buf = Vec::new();
 
-    for file in options.files.into_iter() {
+    for file in &options.files {
         let mut fh = open(file);
 
         while match fh.read_until(b'\n', &mut buf) {
@@ -330,15 +330,12 @@ fn expand(options: Options) {
                         // now dump out either spaces if we're expanding, or a literal tab if we're not
                         if init || !options.iflag {
                             if nts <= options.tspaces.len() {
-                                crash_if_err!(
-                                    1,
-                                    output.write_all(options.tspaces[..nts].as_bytes())
-                                );
+                                output.write_all(options.tspaces[..nts].as_bytes())?;
                             } else {
-                                crash_if_err!(1, output.write_all(" ".repeat(nts).as_bytes()));
+                                output.write_all(" ".repeat(nts).as_bytes())?;
                             };
                         } else {
-                            crash_if_err!(1, output.write_all(&buf[byte..byte + nbytes]));
+                            output.write_all(&buf[byte..byte + nbytes])?;
                         }
                     }
                     _ => {
@@ -356,17 +353,18 @@ fn expand(options: Options) {
                             init = false;
                         }
 
-                        crash_if_err!(1, output.write_all(&buf[byte..byte + nbytes]));
+                        output.write_all(&buf[byte..byte + nbytes])?;
                     }
                 }
 
                 byte += nbytes; // advance the pointer
             }
 
-            crash_if_err!(1, output.flush());
+            output.flush()?;
             buf.truncate(0); // clear the buffer
         }
     }
+    Ok(())
 }
 
 #[cfg(test)]
diff --git a/src/uu/expand/src/main.rs b/src/uu/expand/src/main.rs
index a154b36be..2d88f6187 100644
--- a/src/uu/expand/src/main.rs
+++ b/src/uu/expand/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_expand);
+uucore::bin!(uu_expand);
diff --git a/src/uu/expr/Cargo.toml b/src/uu/expr/Cargo.toml
index 90a53f2ce..79107069f 100644
--- a/src/uu/expr/Cargo.toml
+++ b/src/uu/expr/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_expr"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "expr ~ (uutils) display the value of EXPRESSION"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/expr"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/expr"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,18 +15,12 @@ edition = "2018"
 path = "src/expr.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 num-bigint = "0.4.0"
 num-traits = "0.2.14"
-onig = "~4.3.2"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+onig = { version = "~6.3", default-features = false }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "expr"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/expr/LICENSE b/src/uu/expr/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/expr/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/expr/src/expr.rs b/src/uu/expr/src/expr.rs
index 6e2a8701a..f202b091c 100644
--- a/src/uu/expr/src/expr.rs
+++ b/src/uu/expr/src/expr.rs
@@ -5,7 +5,7 @@
 //* For the full copyright and license information, please view the LICENSE
 //* file that was distributed with this source code.
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use uucore::error::{UResult, USimpleError};
 use uucore::InvalidEncodingHandling;
 
@@ -14,14 +14,26 @@ mod tokens;
 
 const VERSION: &str = "version";
 const HELP: &str = "help";
+static ABOUT: &str = "Print the value of EXPRESSION to standard output";
+static USAGE: &str = r#"
+    expr [EXPRESSION]
+    expr [OPTIONS]"#;
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
-        .arg(Arg::with_name(VERSION).long(VERSION))
-        .arg(Arg::with_name(HELP).long(HELP))
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .version(crate_version!())
+        .about(ABOUT)
+        .override_usage(USAGE)
+        .infer_long_args(true)
+        .arg(
+            Arg::new(VERSION)
+                .long(VERSION)
+                .help("output version information and exit"),
+        )
+        .arg(Arg::new(HELP).long(HELP).help("display this help and exit"))
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
diff --git a/src/uu/expr/src/main.rs b/src/uu/expr/src/main.rs
index 6fdd6be14..1a4134906 100644
--- a/src/uu/expr/src/main.rs
+++ b/src/uu/expr/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_expr);
+uucore::bin!(uu_expr);
diff --git a/src/uu/expr/src/syntax_tree.rs b/src/uu/expr/src/syntax_tree.rs
index ff49ea57e..4dafffbf0 100644
--- a/src/uu/expr/src/syntax_tree.rs
+++ b/src/uu/expr/src/syntax_tree.rs
@@ -7,10 +7,10 @@
 
 //!
 //! 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
+//! * `<https://en.wikipedia.org/wiki/Shunting-yard_algorithm>`
 //!
 
-// spell-checker:ignore (ToDO) binop binops ints paren prec
+// spell-checker:ignore (ToDO) binop binops ints paren prec multibytes
 
 use num_bigint::BigInt;
 use num_traits::{One, Zero};
@@ -66,23 +66,23 @@ impl AstNode {
         }
     }
 
-    fn new_node(token_idx: usize, op_type: &str, operands: OperandsList) -> Box<AstNode> {
-        Box::new(AstNode::Node {
+    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<AstNode> {
-        Box::new(AstNode::Leaf {
+    fn new_leaf(token_idx: usize, value: &str) -> Box<Self> {
+        Box::new(Self::Leaf {
             token_idx,
             value: value.into(),
         })
     }
     pub fn evaluate(&self) -> Result<String, String> {
         match self {
-            AstNode::Leaf { value, .. } => Ok(value.clone()),
-            AstNode::Node { op_type, .. } => match self.operand_values() {
+            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() {
                     "+" => {
@@ -302,12 +302,7 @@ fn push_token_to_either_stack(
             }
         }
 
-        Token::PrefixOp { .. } => {
-            op_stack.push((token_idx, token.clone()));
-            Ok(())
-        }
-
-        Token::ParOpen => {
+        Token::PrefixOp { .. } | Token::ParOpen => {
             op_stack.push((token_idx, token.clone()));
             Ok(())
         }
@@ -352,12 +347,7 @@ fn push_op_to_stack(
     {
         loop {
             match op_stack.last() {
-                None => {
-                    op_stack.push((token_idx, token.clone()));
-                    return Ok(());
-                }
-
-                Some(&(_, Token::ParOpen)) => {
+                None | Some(&(_, Token::ParOpen)) => {
                     op_stack.push((token_idx, token.clone()));
                     return Ok(());
                 }
@@ -370,7 +360,7 @@ fn push_op_to_stack(
                     },
                 )) => {
                     if la && prev_prec >= prec || !la && prev_prec > prec {
-                        out_stack.push(op_stack.pop().unwrap())
+                        out_stack.push(op_stack.pop().unwrap());
                     } else {
                         op_stack.push((token_idx, token.clone()));
                         return Ok(());
@@ -475,7 +465,9 @@ fn operator_match(values: &[String]) -> Result<String, String> {
 
 fn prefix_operator_length(values: &[String]) -> String {
     assert!(values.len() == 1);
-    values[0].len().to_string()
+    // Use chars().count() as we can have some multibytes chars
+    // See https://github.com/uutils/coreutils/issues/3132
+    values[0].chars().count().to_string()
 }
 
 fn prefix_operator_index(values: &[String]) -> String {
diff --git a/src/uu/expr/src/tokens.rs b/src/uu/expr/src/tokens.rs
index 748960bc3..a0365898d 100644
--- a/src/uu/expr/src/tokens.rs
+++ b/src/uu/expr/src/tokens.rs
@@ -42,30 +42,30 @@ pub enum Token {
 }
 impl Token {
     fn new_infix_op(v: &str, left_assoc: bool, precedence: u8) -> Self {
-        Token::InfixOp {
+        Self::InfixOp {
             left_assoc,
             precedence,
             value: v.into(),
         }
     }
     fn new_value(v: &str) -> Self {
-        Token::Value { value: v.into() }
+        Self::Value { value: v.into() }
     }
 
     fn is_infix_plus(&self) -> bool {
         match self {
-            Token::InfixOp { value, .. } => value == "+",
+            Self::InfixOp { value, .. } => value == "+",
             _ => false,
         }
     }
     fn is_a_number(&self) -> bool {
         match self {
-            Token::Value { value, .. } => value.parse::<BigInt>().is_ok(),
+            Self::Value { value, .. } => value.parse::<BigInt>().is_ok(),
             _ => false,
         }
     }
     fn is_a_close_paren(&self) -> bool {
-        matches!(*self, Token::ParClose)
+        matches!(*self, Self::ParClose)
     }
 }
 
@@ -82,25 +82,17 @@ pub fn strings_to_tokens(strings: &[String]) -> Result<Vec<(usize, Token)>, Stri
 
             ":" => Token::new_infix_op(s, true, 6),
 
-            "*" => Token::new_infix_op(s, true, 5),
-            "/" => Token::new_infix_op(s, true, 5),
-            "%" => Token::new_infix_op(s, true, 5),
+            "*" | "/" | "%" => Token::new_infix_op(s, true, 5),
 
-            "+" => Token::new_infix_op(s, true, 4),
-            "-" => Token::new_infix_op(s, true, 4),
+            "+" | "-" => Token::new_infix_op(s, true, 4),
 
-            "=" => Token::new_infix_op(s, true, 3),
-            "!=" => Token::new_infix_op(s, true, 3),
-            "<" => Token::new_infix_op(s, true, 3),
-            ">" => Token::new_infix_op(s, true, 3),
-            "<=" => Token::new_infix_op(s, true, 3),
-            ">=" => Token::new_infix_op(s, true, 3),
+            "=" | "!=" | "<" | ">" | "<=" | ">=" => Token::new_infix_op(s, true, 3),
 
             "&" => Token::new_infix_op(s, true, 2),
 
             "|" => Token::new_infix_op(s, true, 1),
 
-            "match" => Token::PrefixOp {
+            "match" | "index" => Token::PrefixOp {
                 arity: 2,
                 value: s.clone(),
             },
@@ -108,10 +100,6 @@ pub fn strings_to_tokens(strings: &[String]) -> Result<Vec<(usize, Token)>, Stri
                 arity: 3,
                 value: s.clone(),
             },
-            "index" => Token::PrefixOp {
-                arity: 2,
-                value: s.clone(),
-            },
             "length" => Token::PrefixOp {
                 arity: 1,
                 value: s.clone(),
@@ -155,8 +143,8 @@ fn push_token_if_not_escaped(acc: &mut Vec<(usize, Token)>, tok_idx: usize, toke
 
     if should_use_as_escaped {
         acc.pop();
-        acc.push((tok_idx, Token::new_value(s)))
+        acc.push((tok_idx, Token::new_value(s)));
     } else {
-        acc.push((tok_idx, token))
+        acc.push((tok_idx, token));
     }
 }
diff --git a/src/uu/factor/BENCHMARKING.md b/src/uu/factor/BENCHMARKING.md
index 6bf9cbf90..0f9afaff0 100644
--- a/src/uu/factor/BENCHMARKING.md
+++ b/src/uu/factor/BENCHMARKING.md
@@ -44,7 +44,8 @@ on Daniel Lemire's [*Microbenchmarking calls for idealized conditions*][lemire],
 which I recommend reading if you want to add benchmarks to `factor`.
 
 1. Select a small, self-contained, deterministic component
-   `gcd` and `table::factor` are good example of such:
+   (`gcd` and `table::factor` are good examples):
+
    - no I/O or access to external data structures ;
    - no call into other components ;
    - behavior is deterministic: no RNG, no concurrency, ... ;
@@ -53,16 +54,19 @@ which I recommend reading if you want to add benchmarks to `factor`.
      maximizing the numbers of samples we can take in a given time.
 
 2. Benchmarks are immutable (once merged in `uutils`)
+
    Modifying a benchmark means previously-collected values cannot meaningfully
    be compared, silently giving nonsensical results.  If you must modify an
    existing benchmark, rename it.
 
 3. Test common cases
+
    We are interested in overall performance, rather than specific edge-cases;
    use **reproducibly-randomized inputs**, sampling from either all possible
    input values or some subset of interest.
 
 4. Use [`criterion`], `criterion::black_box`, ...
+
    `criterion` isn't perfect, but it is also much better than ad-hoc
    solutions in each benchmark.
 
diff --git a/src/uu/factor/Cargo.toml b/src/uu/factor/Cargo.toml
index 2d2fa236b..b1d2d9560 100644
--- a/src/uu/factor/Cargo.toml
+++ b/src/uu/factor/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_factor"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "factor ~ (uutils) display the prime factors of each NUMBER"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,18 +15,16 @@ edition = "2018"
 num-traits = "0.2.13" # used in src/numerics.rs, which is included by build.rs
 
 [dependencies]
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 coz = { version = "0.1.3", optional = true }
 num-traits = "0.2.13" # Needs at least version 0.2.13 for "OverflowingAdd"
-rand = { version = "0.7", features = ["small_rng"] }
-smallvec = { version = "0.6.14, < 1.0" }
+rand = { version = "0.8", features = ["small_rng"] }
+smallvec = "1.7"  # TODO(nicoo): Use `union` feature, requires Rust 1.49 or later.
 uucore = { version = ">=0.0.8", package = "uucore", path = "../../uucore" }
-uucore_procs = { version=">=0.0.7", package = "uucore_procs", path = "../../uucore_procs" }
-clap = { version = "2.33", features = ["wrap_help"] }
 
 [dev-dependencies]
-paste = "0.1.18"
-quickcheck = "0.9.2"
-
+paste = "1.0.6"
+quickcheck = "1.0.3"
 
 [[bin]]
 name = "factor"
@@ -34,7 +32,3 @@ path = "src/main.rs"
 
 [lib]
 path = "src/cli.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/factor/LICENSE b/src/uu/factor/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/factor/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/factor/sieve.rs b/src/uu/factor/sieve.rs
index 492c8159f..e7d499151 100644
--- a/src/uu/factor/sieve.rs
+++ b/src/uu/factor/sieve.rs
@@ -15,6 +15,7 @@ use std::slice::Iter;
 /// This is a reasonably efficient implementation based on
 /// O'Neill, M. E. "[The Genuine Sieve of Eratosthenes.](http://dx.doi.org/10.1017%2FS0956796808007004)"
 /// Journal of Functional Programming, Volume 19, Issue 1, 2009, pp.  95--106.
+#[derive(Default)]
 pub struct Sieve {
     inner: Wheel,
     filts: PrimeHeap,
@@ -58,23 +59,20 @@ impl Iterator for Sieve {
 }
 
 impl Sieve {
-    fn new() -> Sieve {
-        Sieve {
-            inner: Wheel::new(),
-            filts: PrimeHeap::new(),
-        }
+    fn new() -> Self {
+        Self::default()
     }
 
     #[allow(dead_code)]
     #[inline]
     pub fn primes() -> PrimeSieve {
-        INIT_PRIMES.iter().copied().chain(Sieve::new())
+        INIT_PRIMES.iter().copied().chain(Self::new())
     }
 
     #[allow(dead_code)]
     #[inline]
     pub fn odd_primes() -> PrimeSieve {
-        (&INIT_PRIMES[1..]).iter().copied().chain(Sieve::new())
+        INIT_PRIMES[1..].iter().copied().chain(Self::new())
     }
 }
 
@@ -106,14 +104,20 @@ impl Iterator for Wheel {
 
 impl Wheel {
     #[inline]
-    fn new() -> Wheel {
-        Wheel {
+    fn new() -> Self {
+        Self {
             next: 11u64,
             increment: WHEEL_INCS.iter().cycle(),
         }
     }
 }
 
+impl Default for Wheel {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// The increments of a wheel of circumference 210
 /// (i.e., a wheel that skips all multiples of 2, 3, 5, 7)
 const WHEEL_INCS: &[u64] = &[
@@ -124,16 +128,12 @@ const INIT_PRIMES: &[u64] = &[2, 3, 5, 7];
 
 /// A min-heap of "infinite lists" of prime multiples, where a list is
 /// represented as (head, increment).
-#[derive(Debug)]
+#[derive(Debug, Default)]
 struct PrimeHeap {
     data: Vec<(u64, u64)>,
 }
 
 impl PrimeHeap {
-    fn new() -> PrimeHeap {
-        PrimeHeap { data: Vec::new() }
-    }
-
     fn peek(&self) -> Option<(u64, u64)> {
         if let Some(&(x, y)) = self.data.get(0) {
             Some((x, y))
diff --git a/src/uu/factor/src/cli.rs b/src/uu/factor/src/cli.rs
index 30541c244..f78e410ba 100644
--- a/src/uu/factor/src/cli.rs
+++ b/src/uu/factor/src/cli.rs
@@ -14,9 +14,10 @@ use std::fmt::Write as FmtWrite;
 use std::io::{self, stdin, stdout, BufRead, Write};
 
 mod factor;
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 pub use factor::*;
 use uucore::display::Quotable;
+use uucore::error::UResult;
 
 mod miller_rabin;
 pub mod numeric;
@@ -43,7 +44,8 @@ fn print_factors_str(
     })
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().get_matches_from(args);
     let stdout = stdout();
     // We use a smaller buffer here to pass a gnu test. 4KiB appears to be the default pipe size for bash.
@@ -72,12 +74,13 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         show_error!("{}", e);
     }
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(SUMMARY)
-        .arg(Arg::with_name(options::NUMBER).multiple(true))
+        .infer_long_args(true)
+        .arg(Arg::new(options::NUMBER).multiple_occurrences(true))
 }
diff --git a/src/uu/factor/src/factor.rs b/src/uu/factor/src/factor.rs
index 54ad0bdd4..c776f95ea 100644
--- a/src/uu/factor/src/factor.rs
+++ b/src/uu/factor/src/factor.rs
@@ -14,7 +14,7 @@ use crate::{miller_rabin, rho, table};
 
 type Exponent = u8;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 struct Decomposition(SmallVec<[(u64, Exponent); NUM_FACTORS_INLINE]>);
 
 // spell-checker:ignore (names) Erdős–Kac * Erdős Kac
@@ -24,8 +24,8 @@ struct Decomposition(SmallVec<[(u64, Exponent); NUM_FACTORS_INLINE]>);
 const NUM_FACTORS_INLINE: usize = 5;
 
 impl Decomposition {
-    fn one() -> Decomposition {
-        Decomposition(SmallVec::new())
+    fn one() -> Self {
+        Self::default()
     }
 
     fn add(&mut self, factor: u64, exp: Exponent) {
@@ -34,7 +34,7 @@ impl Decomposition {
         if let Some((_, e)) = self.0.iter_mut().find(|(f, _)| *f == factor) {
             *e += exp;
         } else {
-            self.0.push((factor, exp))
+            self.0.push((factor, exp));
         }
     }
 
@@ -51,7 +51,7 @@ impl Decomposition {
 }
 
 impl PartialEq for Decomposition {
-    fn eq(&self, other: &Decomposition) -> bool {
+    fn eq(&self, other: &Self) -> bool {
         for p in &self.0 {
             if other.get(p.0) != Some(p) {
                 return false;
@@ -73,17 +73,17 @@ impl Eq for Decomposition {}
 pub struct Factors(RefCell<Decomposition>);
 
 impl Factors {
-    pub fn one() -> Factors {
-        Factors(RefCell::new(Decomposition::one()))
+    pub fn one() -> Self {
+        Self(RefCell::new(Decomposition::one()))
     }
 
     pub fn add(&mut self, prime: u64, exp: Exponent) {
         debug_assert!(miller_rabin::is_prime(prime));
-        self.0.borrow_mut().add(prime, exp)
+        self.0.borrow_mut().add(prime, exp);
     }
 
     pub fn push(&mut self, prime: u64) {
-        self.add(prime, 1)
+        self.add(prime, 1);
     }
 
     #[cfg(test)]
@@ -99,7 +99,7 @@ impl fmt::Display for Factors {
 
         for (p, exp) in v.iter() {
             for _ in 0..*exp {
-                write!(f, " {}", p)?
+                write!(f, " {}", p)?;
             }
         }
 
@@ -258,7 +258,7 @@ impl Distribution<Factors> for Standard {
         // See Generating Random Factored Numbers, Easily, J. Cryptology (2003)
         'attempt: loop {
             while n > 1 {
-                n = rng.gen_range(1, n);
+                n = rng.gen_range(1..n);
                 if miller_rabin::is_prime(n) {
                     if let Some(h) = g.checked_mul(n) {
                         f.push(n);
@@ -277,8 +277,8 @@ impl Distribution<Factors> for Standard {
 
 #[cfg(test)]
 impl quickcheck::Arbitrary for Factors {
-    fn arbitrary<G: quickcheck::Gen>(g: &mut G) -> Self {
-        g.gen()
+    fn arbitrary(g: &mut quickcheck::Gen) -> Self {
+        factor(u64::arbitrary(g))
     }
 }
 
@@ -286,9 +286,9 @@ impl quickcheck::Arbitrary for Factors {
 impl std::ops::BitXor<Exponent> for Factors {
     type Output = Self;
 
-    fn bitxor(self, rhs: Exponent) -> Factors {
+    fn bitxor(self, rhs: Exponent) -> Self {
         debug_assert_ne!(rhs, 0);
-        let mut r = Factors::one();
+        let mut r = Self::one();
         for (p, e) in self.0.borrow().0.iter() {
             r.add(*p, rhs * e);
         }
diff --git a/src/uu/factor/src/main.rs b/src/uu/factor/src/main.rs
index 4d8b281b6..d091c02cb 100644
--- a/src/uu/factor/src/main.rs
+++ b/src/uu/factor/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_factor);
+uucore::bin!(uu_factor);
diff --git a/src/uu/factor/src/miller_rabin.rs b/src/uu/factor/src/miller_rabin.rs
index ec6d81c0f..b5a01735a 100644
--- a/src/uu/factor/src/miller_rabin.rs
+++ b/src/uu/factor/src/miller_rabin.rs
@@ -42,7 +42,7 @@ pub(crate) enum Result {
 
 impl Result {
     pub(crate) fn is_prime(&self) -> bool {
-        *self == Result::Prime
+        *self == Self::Prime
     }
 }
 
@@ -200,7 +200,11 @@ mod tests {
 
     quickcheck! {
         fn composites(i: u64, j: u64) -> bool {
-            i < 2 || j < 2 || !is_prime(i*j)
+            // TODO: #1559 factor n > 2^64 - 1
+            match i.checked_mul(j) {
+                Some(n) => i < 2 || j < 2 || !is_prime(n),
+                _ => true,
+            }
         }
     }
 }
diff --git a/src/uu/factor/src/numeric/gcd.rs b/src/uu/factor/src/numeric/gcd.rs
index 004ef1515..089318f48 100644
--- a/src/uu/factor/src/numeric/gcd.rs
+++ b/src/uu/factor/src/numeric/gcd.rs
@@ -6,6 +6,8 @@
 // * For the full copyright and license information, please view the LICENSE file
 // * that was distributed with this source code.
 
+// spell-checker:ignore (vars) kgcdab gcdac gcdbc
+
 use std::cmp::min;
 use std::mem::swap;
 
@@ -52,7 +54,7 @@ pub fn gcd(mut u: u64, mut v: u64) -> u64 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use quickcheck::quickcheck;
+    use quickcheck::{quickcheck, TestResult};
 
     quickcheck! {
         fn euclidean(a: u64, b: u64) -> bool {
@@ -76,13 +78,12 @@ mod tests {
             gcd(0, a) == a
         }
 
-        fn divisor(a: u64, b: u64) -> () {
+        fn divisor(a: u64, b: u64) -> TestResult {
             // Test that gcd(a, b) divides a and b, unless a == b == 0
-            if a == 0 && b == 0 { return; }
+            if a == 0 && b == 0 { return TestResult::discard(); } // restrict test domain to !(a == b == 0)
 
             let g = gcd(a, b);
-            assert_eq!(a % g, 0);
-            assert_eq!(b % g, 0);
+            TestResult::from_bool( g != 0 && a % g == 0 && b % g == 0 )
         }
 
         fn commutative(a: u64, b: u64) -> bool {
@@ -94,16 +95,35 @@ mod tests {
         }
 
         fn scalar_multiplication(a: u64, b: u64, k: u64) -> bool {
-            gcd(k * a, k * b) == k * gcd(a, b)
+            // TODO: #1559 factor n > 2^64 - 1
+            match (k.checked_mul(a), k.checked_mul(b), k.checked_mul(gcd(a, b))) {
+                (Some(ka), Some(kb), Some(kgcdab)) => gcd(ka, kb) == kgcdab,
+                _ => true
+            }
         }
 
         fn multiplicative(a: u64, b: u64, c: u64) -> bool {
-            // gcd(ab, c) = gcd(a, c) gcd(b, c) when a and b coprime
-            gcd(a, b) != 1 || gcd(a * b, c) == gcd(a, c) * gcd(b, c)
+            // TODO: #1559 factor n > 2^64 - 1
+            match (a.checked_mul(b), gcd(a, c).checked_mul(gcd(b, c))) {
+                (Some(ab), Some(gcdac_gcdbc)) => {
+                    // gcd(ab, c) = gcd(a, c) gcd(b, c) when a and b coprime
+                    gcd(a, b) != 1 || gcd(ab, c) == gcdac_gcdbc
+                },
+                _ => true,
+            }
         }
 
         fn linearity(a: u64, b: u64, k: u64) -> bool {
-            gcd(a + k * b, b) == gcd(a, b)
+            // TODO: #1559 factor n > 2^64 - 1
+            match k.checked_mul(b) {
+                Some(kb) => {
+                    match a.checked_add(kb) {
+                        Some(a_plus_kb) => gcd(a_plus_kb, b) == gcd(a, b),
+                        _ => true,
+                    }
+                }
+                _ => true,
+            }
         }
     }
 }
diff --git a/src/uu/factor/src/numeric/modular_inverse.rs b/src/uu/factor/src/numeric/modular_inverse.rs
index e4827a3ee..5b37a9782 100644
--- a/src/uu/factor/src/numeric/modular_inverse.rs
+++ b/src/uu/factor/src/numeric/modular_inverse.rs
@@ -63,13 +63,17 @@ mod tests {
 
     quickcheck! {
         fn random_values_u32(n: u32) -> bool {
-            let n = 2 * n + 1;
-            modular_inverse(n).wrapping_mul(n) == 1
+            match 2_u32.checked_mul(n) {
+                Some(n) => modular_inverse(n + 1).wrapping_mul(n + 1) == 1,
+                _ => true,
+            }
         }
 
         fn random_values_u64(n: u64) -> bool {
-            let n = 2 * n + 1;
-            modular_inverse(n).wrapping_mul(n) == 1
+            match 2_u64.checked_mul(n) {
+                Some(n) => modular_inverse(n + 1).wrapping_mul(n + 1) == 1,
+                _ => true,
+            }
         }
     }
 }
diff --git a/src/uu/factor/src/numeric/montgomery.rs b/src/uu/factor/src/numeric/montgomery.rs
index 485025d87..504e6a09b 100644
--- a/src/uu/factor/src/numeric/montgomery.rs
+++ b/src/uu/factor/src/numeric/montgomery.rs
@@ -106,7 +106,7 @@ impl<T: DoubleInt> Arithmetic for Montgomery<T> {
         let n = T::from_u64(n);
         let a = modular_inverse(n).wrapping_neg();
         debug_assert_eq!(n.wrapping_mul(&a), T::one().wrapping_neg());
-        Montgomery { a, n }
+        Self { a, n }
     }
 
     fn modulus(&self) -> u64 {
diff --git a/src/uu/factor/src/numeric/traits.rs b/src/uu/factor/src/numeric/traits.rs
index 2e9167e0b..1dc681976 100644
--- a/src/uu/factor/src/numeric/traits.rs
+++ b/src/uu/factor/src/numeric/traits.rs
@@ -61,7 +61,7 @@ macro_rules! double_int {
             fn as_double_width(self) -> $y {
                 self as _
             }
-            fn from_double_width(n: $y) -> $x {
+            fn from_double_width(n: $y) -> Self {
                 n as _
             }
         }
diff --git a/src/uu/false/Cargo.toml b/src/uu/false/Cargo.toml
index 2a725e2b0..3a4c7cc4e 100644
--- a/src/uu/false/Cargo.toml
+++ b/src/uu/false/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_false"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "false ~ (uutils) do nothing and fail"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/false"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/false"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/false.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "false"
diff --git a/src/uu/false/LICENSE b/src/uu/false/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/false/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/false/src/false.rs b/src/uu/false/src/false.rs
index 783c7fa0d..687235f70 100644
--- a/src/uu/false/src/false.rs
+++ b/src/uu/false/src/false.rs
@@ -4,16 +4,63 @@
 //  *
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
+use clap::{Arg, Command};
+use std::io::Write;
+use uucore::error::{set_exit_code, UResult};
 
-use clap::App;
-use uucore::error::UResult;
+static ABOUT: &str = "\
+Returns false, an unsuccessful exit status.
 
-#[uucore_procs::gen_uumain]
+Immediately returns with the exit status `1`. When invoked with one of the recognized options it
+will try to write the help or version text. Any IO error during this operation is diagnosed, yet
+the program will also return `1`.
+";
+
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    uu_app().get_matches_from(args);
-    Err(1.into())
+    let mut command = uu_app();
+
+    // Mirror GNU options, always return `1`. In particular even the 'successful' cases of no-op,
+    // and the interrupted display of help and version should return `1`. Also, we return Ok in all
+    // paths to avoid the allocation of an error object, an operation that could, in theory, fail
+    // and unwind through the standard library allocation handling machinery.
+    set_exit_code(1);
+
+    if let Ok(matches) = command.try_get_matches_from_mut(args) {
+        let error = if matches.index_of("help").is_some() {
+            command.print_long_help()
+        } else if matches.index_of("version").is_some() {
+            writeln!(std::io::stdout(), "{}", command.render_version())
+        } else {
+            Ok(())
+        };
+
+        // Try to display this error.
+        if let Err(print_fail) = error {
+            // Completely ignore any error here, no more failover and we will fail in any case.
+            let _ = writeln!(std::io::stderr(), "{}: {}", uucore::util_name(), print_fail);
+        }
+    }
+
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .version(clap::crate_version!())
+        .about(ABOUT)
+        // We provide our own help and version options, to ensure maximum compatibility with GNU.
+        .disable_help_flag(true)
+        .disable_version_flag(true)
+        .arg(
+            Arg::new("help")
+                .long("help")
+                .help("Print help information")
+                .exclusive(true),
+        )
+        .arg(
+            Arg::new("version")
+                .long("version")
+                .help("Print version information"),
+        )
 }
diff --git a/src/uu/false/src/main.rs b/src/uu/false/src/main.rs
index 382a16fc7..3b46ec126 100644
--- a/src/uu/false/src/main.rs
+++ b/src/uu/false/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_false);
+uucore::bin!(uu_false);
diff --git a/src/uu/fmt/Cargo.toml b/src/uu/fmt/Cargo.toml
index a4700cb5e..714b75ffe 100644
--- a/src/uu/fmt/Cargo.toml
+++ b/src/uu/fmt/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_fmt"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "fmt ~ (uutils) reformat each paragraph of input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/fmt"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/fmt"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,16 +15,10 @@ edition = "2018"
 path = "src/fmt.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 unicode-width = "0.1.5"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "fmt"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/fmt/LICENSE b/src/uu/fmt/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/fmt/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/fmt/src/fmt.rs b/src/uu/fmt/src/fmt.rs
index 669c98b14..3cb851674 100644
--- a/src/uu/fmt/src/fmt.rs
+++ b/src/uu/fmt/src/fmt.rs
@@ -10,29 +10,23 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::cmp;
 use std::fs::File;
 use std::io::{stdin, stdout, Write};
 use std::io::{BufReader, BufWriter, Read};
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::format_usage;
 
 use self::linebreak::break_lines;
 use self::parasplit::ParagraphStream;
 
-macro_rules! silent_unwrap(
-    ($exp:expr) => (
-        match $exp {
-            Ok(_) => (),
-            Err(_) => ::std::process::exit(1),
-        }
-    )
-);
-
 mod linebreak;
 mod parasplit;
 
 static ABOUT: &str = "Reformat paragraphs from input files (or stdin) to stdout.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 static MAX_WIDTH: usize = 2500;
 
 static OPT_CROWN_MARGIN: &str = "crown-margin";
@@ -51,10 +45,6 @@ static OPT_TAB_WIDTH: &str = "tab-width";
 
 static ARG_FILES: &str = "files";
 
-fn usage() -> String {
-    format!("{} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
-
 pub type FileOrStdReader = BufReader<Box<dyn Read + 'static>>;
 pub struct FmtOptions {
     crown: bool,
@@ -74,11 +64,10 @@ pub struct FmtOptions {
     tabwidth: usize,
 }
 
+#[uucore::main]
 #[allow(clippy::cognitive_complexity)]
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let mut files: Vec<String> = matches
         .values_of(ARG_FILES)
@@ -133,15 +122,20 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         fmt_opts.width = match s.parse::<usize>() {
             Ok(t) => t,
             Err(e) => {
-                crash!(1, "Invalid WIDTH specification: {}: {}", s.quote(), e);
+                return Err(USimpleError::new(
+                    1,
+                    format!("Invalid WIDTH specification: {}: {}", s.quote(), e),
+                ));
             }
         };
         if fmt_opts.width > MAX_WIDTH {
-            crash!(
+            return Err(USimpleError::new(
                 1,
-                "invalid width: '{}': Numerical result out of range",
-                fmt_opts.width
-            );
+                format!(
+                    "invalid width: '{}': Numerical result out of range",
+                    fmt_opts.width,
+                ),
+            ));
         }
         fmt_opts.goal = cmp::min(fmt_opts.width * 94 / 100, fmt_opts.width - 3);
     };
@@ -150,13 +144,16 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         fmt_opts.goal = match s.parse::<usize>() {
             Ok(t) => t,
             Err(e) => {
-                crash!(1, "Invalid GOAL specification: {}: {}", s.quote(), e);
+                return Err(USimpleError::new(
+                    1,
+                    format!("Invalid GOAL specification: {}: {}", s.quote(), e),
+                ));
             }
         };
         if !matches.is_present(OPT_WIDTH) {
             fmt_opts.width = cmp::max(fmt_opts.goal * 100 / 94, fmt_opts.goal + 3);
         } else if fmt_opts.goal > fmt_opts.width {
-            crash!(1, "GOAL cannot be greater than WIDTH.");
+            return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
         }
     };
 
@@ -164,7 +161,10 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         fmt_opts.tabwidth = match s.parse::<usize>() {
             Ok(t) => t,
             Err(e) => {
-                crash!(1, "Invalid TABWIDTH specification: {}: {}", s.quote(), e);
+                return Err(USimpleError::new(
+                    1,
+                    format!("Invalid TABWIDTH specification: {}: {}", s.quote(), e),
+                ));
             }
         };
     };
@@ -197,27 +197,36 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         for para_result in p_stream {
             match para_result {
                 Err(s) => {
-                    silent_unwrap!(ostream.write_all(s.as_bytes()));
-                    silent_unwrap!(ostream.write_all(b"\n"));
+                    ostream
+                        .write_all(s.as_bytes())
+                        .map_err_context(|| "failed to write output".to_string())?;
+                    ostream
+                        .write_all(b"\n")
+                        .map_err_context(|| "failed to write output".to_string())?;
                 }
-                Ok(para) => break_lines(&para, &fmt_opts, &mut ostream),
+                Ok(para) => break_lines(&para, &fmt_opts, &mut ostream)
+                    .map_err_context(|| "failed to write output".to_string())?,
             }
         }
 
         // flush the output after each file
-        silent_unwrap!(ostream.flush());
+        ostream
+            .flush()
+            .map_err_context(|| "failed to write output".to_string())?;
     }
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_CROWN_MARGIN)
-                .short("c")
+            Arg::new(OPT_CROWN_MARGIN)
+                .short('c')
                 .long(OPT_CROWN_MARGIN)
                 .help(
                     "First and second line of paragraph \
@@ -227,8 +236,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_TAGGED_PARAGRAPH)
-                .short("t")
+            Arg::new(OPT_TAGGED_PARAGRAPH)
+                .short('t')
                 .long("tagged-paragraph")
                 .help(
                     "Like -c, except that the first and second line of a paragraph *must* \
@@ -236,8 +245,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_PRESERVE_HEADERS)
-                .short("m")
+            Arg::new(OPT_PRESERVE_HEADERS)
+                .short('m')
                 .long("preserve-headers")
                 .help(
                     "Attempt to detect and preserve mail headers in the input. \
@@ -245,14 +254,14 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_SPLIT_ONLY)
-                .short("s")
+            Arg::new(OPT_SPLIT_ONLY)
+                .short('s')
                 .long("split-only")
                 .help("Split lines only, do not reflow."),
         )
         .arg(
-            Arg::with_name(OPT_UNIFORM_SPACING)
-                .short("u")
+            Arg::new(OPT_UNIFORM_SPACING)
+                .short('u')
                 .long("uniform-spacing")
                 .help(
                     "Insert exactly one \
@@ -263,8 +272,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_PREFIX)
-                .short("p")
+            Arg::new(OPT_PREFIX)
+                .short('p')
                 .long("prefix")
                 .help(
                     "Reformat only lines \
@@ -275,8 +284,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .value_name("PREFIX"),
         )
         .arg(
-            Arg::with_name(OPT_SKIP_PREFIX)
-                .short("P")
+            Arg::new(OPT_SKIP_PREFIX)
+                .short('P')
                 .long("skip-prefix")
                 .help(
                     "Do not reformat lines \
@@ -286,8 +295,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .value_name("PSKIP"),
         )
         .arg(
-            Arg::with_name(OPT_EXACT_PREFIX)
-                .short("x")
+            Arg::new(OPT_EXACT_PREFIX)
+                .short('x')
                 .long("exact-prefix")
                 .help(
                     "PREFIX must match at the \
@@ -295,8 +304,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_EXACT_SKIP_PREFIX)
-                .short("X")
+            Arg::new(OPT_EXACT_SKIP_PREFIX)
+                .short('X')
                 .long("exact-skip-prefix")
                 .help(
                     "PSKIP must match at the \
@@ -304,26 +313,26 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_WIDTH)
-                .short("w")
+            Arg::new(OPT_WIDTH)
+                .short('w')
                 .long("width")
                 .help("Fill output lines up to a maximum of WIDTH columns, default 79.")
                 .value_name("WIDTH"),
         )
         .arg(
-            Arg::with_name(OPT_GOAL)
-                .short("g")
+            Arg::new(OPT_GOAL)
+                .short('g')
                 .long("goal")
                 .help("Goal width, default ~0.94*WIDTH. Must be less than WIDTH.")
                 .value_name("GOAL"),
         )
-        .arg(Arg::with_name(OPT_QUICK).short("q").long("quick").help(
+        .arg(Arg::new(OPT_QUICK).short('q').long("quick").help(
             "Break lines more quickly at the \
             expense of a potentially more ragged appearance.",
         ))
         .arg(
-            Arg::with_name(OPT_TAB_WIDTH)
-                .short("T")
+            Arg::new(OPT_TAB_WIDTH)
+                .short('T')
                 .long("tab-width")
                 .help(
                     "Treat tabs as TABWIDTH spaces for \
@@ -332,5 +341,9 @@ pub fn uu_app() -> App<'static, 'static> {
                 )
                 .value_name("TABWIDTH"),
         )
-        .arg(Arg::with_name(ARG_FILES).multiple(true).takes_value(true))
+        .arg(
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
+                .takes_value(true),
+        )
 }
diff --git a/src/uu/fmt/src/linebreak.rs b/src/uu/fmt/src/linebreak.rs
index fe9f8568e..40699d22e 100644
--- a/src/uu/fmt/src/linebreak.rs
+++ b/src/uu/fmt/src/linebreak.rs
@@ -40,7 +40,11 @@ impl<'a> BreakArgs<'a> {
     }
 }
 
-pub fn break_lines(para: &Paragraph, opts: &FmtOptions, ostream: &mut BufWriter<Stdout>) {
+pub fn break_lines(
+    para: &Paragraph,
+    opts: &FmtOptions,
+    ostream: &mut BufWriter<Stdout>,
+) -> std::io::Result<()> {
     // indent
     let p_indent = &para.indent_str[..];
     let p_indent_len = para.indent_len;
@@ -54,26 +58,25 @@ pub fn break_lines(para: &Paragraph, opts: &FmtOptions, ostream: &mut BufWriter<
     let (w, w_len) = match p_words_words.next() {
         Some(winfo) => (winfo.word, winfo.word_nchars),
         None => {
-            silent_unwrap!(ostream.write_all(b"\n"));
-            return;
+            return ostream.write_all(b"\n");
         }
     };
     // print the init, if it exists, and get its length
     let p_init_len = w_len
         + if opts.crown || opts.tagged {
             // handle "init" portion
-            silent_unwrap!(ostream.write_all(para.init_str.as_bytes()));
+            ostream.write_all(para.init_str.as_bytes())?;
             para.init_len
         } else if !para.mail_header {
             // for non-(crown, tagged) that's the same as a normal indent
-            silent_unwrap!(ostream.write_all(p_indent.as_bytes()));
+            ostream.write_all(p_indent.as_bytes())?;
             p_indent_len
         } else {
             // except that mail headers get no indent at all
             0
         };
     // write first word after writing init
-    silent_unwrap!(ostream.write_all(w.as_bytes()));
+    ostream.write_all(w.as_bytes())?;
 
     // does this paragraph require uniform spacing?
     let uniform = para.mail_header || opts.uniform;
@@ -88,26 +91,29 @@ pub fn break_lines(para: &Paragraph, opts: &FmtOptions, ostream: &mut BufWriter<
     };
 
     if opts.quick || para.mail_header {
-        break_simple(p_words_words, &mut break_args);
+        break_simple(p_words_words, &mut break_args)
     } else {
-        break_knuth_plass(p_words_words, &mut break_args);
+        break_knuth_plass(p_words_words, &mut break_args)
     }
 }
 
 // break_simple implements a "greedy" breaking algorithm: print words until
 // maxlength would be exceeded, then print a linebreak and indent and continue.
-fn break_simple<'a, T: Iterator<Item = &'a WordInfo<'a>>>(iter: T, args: &mut BreakArgs<'a>) {
-    iter.fold((args.init_len, false), |l, winfo| {
+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)
-    });
-    silent_unwrap!(args.ostream.write_all(b"\n"));
+    })?;
+    args.ostream.write_all(b"\n")
 }
 
 fn accum_words_simple<'a>(
     args: &mut BreakArgs<'a>,
     (l, prev_punct): (usize, bool),
     winfo: &'a WordInfo<'a>,
-) -> (usize, bool) {
+) -> std::io::Result<(usize, bool)> {
     // compute the length of this word, considering how tabs will expand at this position on the line
     let wlen = winfo.word_nchars + args.compute_width(winfo, l, false);
 
@@ -119,12 +125,12 @@ fn accum_words_simple<'a>(
     );
 
     if l + wlen + slen > args.opts.width {
-        write_newline(args.indent_str, args.ostream);
-        write_with_spaces(&winfo.word[winfo.word_start..], 0, args.ostream);
-        (args.indent_len + winfo.word_nchars, winfo.ends_punct)
+        write_newline(args.indent_str, args.ostream)?;
+        write_with_spaces(&winfo.word[winfo.word_start..], 0, args.ostream)?;
+        Ok((args.indent_len + winfo.word_nchars, winfo.ends_punct))
     } else {
-        write_with_spaces(winfo.word, slen, args.ostream);
-        (l + wlen + slen, winfo.ends_punct)
+        write_with_spaces(winfo.word, slen, args.ostream)?;
+        Ok((l + wlen + slen, winfo.ends_punct))
     }
 }
 
@@ -135,16 +141,16 @@ fn accum_words_simple<'a>(
 fn break_knuth_plass<'a, T: Clone + Iterator<Item = &'a WordInfo<'a>>>(
     mut iter: T,
     args: &mut BreakArgs<'a>,
-) {
+) -> std::io::Result<()> {
     // run the algorithm to get the breakpoints
     let breakpoints = find_kp_breakpoints(iter.clone(), args);
 
     // iterate through the breakpoints (note that breakpoints is in reverse break order, so we .rev() it
-    let (mut prev_punct, mut fresh) = breakpoints.iter().rev().fold(
+    let result: std::io::Result<(bool, bool)> = breakpoints.iter().rev().try_fold(
         (false, false),
         |(mut prev_punct, mut fresh), &(next_break, break_before)| {
             if fresh {
-                write_newline(args.indent_str, args.ostream);
+                write_newline(args.indent_str, args.ostream)?;
             }
             // at each breakpoint, keep emitting words until we find the word matching this breakpoint
             for winfo in &mut iter {
@@ -167,26 +173,27 @@ fn break_knuth_plass<'a, T: Clone + Iterator<Item = &'a WordInfo<'a>>>(
                 if winfo_ptr == next_break_ptr {
                     // OK, we found the matching word
                     if break_before {
-                        write_newline(args.indent_str, args.ostream);
-                        write_with_spaces(&winfo.word[winfo.word_start..], 0, args.ostream);
+                        write_newline(args.indent_str, args.ostream)?;
+                        write_with_spaces(&winfo.word[winfo.word_start..], 0, args.ostream)?;
                     } else {
                         // breaking after this word, so that means "fresh" is true for the next iteration
-                        write_with_spaces(word, slen, args.ostream);
+                        write_with_spaces(word, slen, args.ostream)?;
                         fresh = true;
                     }
                     break;
                 } else {
-                    write_with_spaces(word, slen, args.ostream);
+                    write_with_spaces(word, slen, args.ostream)?;
                 }
             }
-            (prev_punct, fresh)
+            Ok((prev_punct, fresh))
         },
     );
+    let (mut prev_punct, mut fresh) = result?;
 
     // after the last linebreak, write out the rest of the final line.
     for winfo in iter {
         if fresh {
-            write_newline(args.indent_str, args.ostream);
+            write_newline(args.indent_str, args.ostream)?;
         }
         let (slen, word) = slice_if_fresh(
             fresh,
@@ -199,9 +206,9 @@ fn break_knuth_plass<'a, T: Clone + Iterator<Item = &'a WordInfo<'a>>>(
         );
         prev_punct = winfo.ends_punct;
         fresh = false;
-        write_with_spaces(word, slen, args.ostream);
+        write_with_spaces(word, slen, args.ostream)?;
     }
-    silent_unwrap!(args.ostream.write_all(b"\n"));
+    args.ostream.write_all(b"\n")
 }
 
 struct LineBreak<'a> {
@@ -377,7 +384,7 @@ fn build_best_path<'a>(paths: &[LineBreak<'a>], active: &[usize]) -> Vec<(&'a Wo
             None => return breakwords,
             Some(prev) => {
                 breakwords.push((prev, next_best.break_before));
-                best_idx = next_best.prev
+                best_idx = next_best.prev;
             }
         }
     }
@@ -405,7 +412,7 @@ fn compute_demerits(delta_len: isize, stretch: isize, wlen: isize, prev_rat: f32
     let bad_linelen = if ratio.abs() > 1.0f32 {
         BAD_INFTY
     } else {
-        (BAD_MULT * ratio.powf(3f32).abs()) as i64
+        (BAD_MULT * ratio.powi(3).abs()) as i64
     };
 
     // we penalize lines ending in really short words
@@ -414,12 +421,12 @@ fn compute_demerits(delta_len: isize, stretch: isize, wlen: isize, prev_rat: f32
     } else {
         (DL_MULT
             * ((stretch - wlen) as f32 / (stretch - 1) as f32)
-                .powf(3f32)
+                .powi(3)
                 .abs()) as i64
     };
 
     // we penalize lines that have very different ratios from previous lines
-    let bad_delta_r = (DR_MULT * (((ratio - prev_rat) / 2.0).powf(3f32)).abs()) as i64;
+    let bad_delta_r = (DR_MULT * (((ratio - prev_rat) / 2.0).powi(3)).abs()) as i64;
 
     let demerits = i64::pow(1 + bad_linelen + bad_wordlen + bad_delta_r, 2);
 
@@ -494,17 +501,21 @@ fn slice_if_fresh(
 }
 
 // Write a newline and add the indent.
-fn write_newline(indent: &str, ostream: &mut BufWriter<Stdout>) {
-    silent_unwrap!(ostream.write_all(b"\n"));
-    silent_unwrap!(ostream.write_all(indent.as_bytes()));
+fn write_newline(indent: &str, ostream: &mut BufWriter<Stdout>) -> std::io::Result<()> {
+    ostream.write_all(b"\n")?;
+    ostream.write_all(indent.as_bytes())
 }
 
 // Write the word, along with slen spaces.
-fn write_with_spaces(word: &str, slen: usize, ostream: &mut BufWriter<Stdout>) {
+fn write_with_spaces(
+    word: &str,
+    slen: usize,
+    ostream: &mut BufWriter<Stdout>,
+) -> std::io::Result<()> {
     if slen == 2 {
-        silent_unwrap!(ostream.write_all(b"  "));
+        ostream.write_all(b"  ")?;
     } else if slen == 1 {
-        silent_unwrap!(ostream.write_all(b" "));
+        ostream.write_all(b" ")?;
     }
-    silent_unwrap!(ostream.write_all(word.as_bytes()));
+    ostream.write_all(word.as_bytes())
 }
diff --git a/src/uu/fmt/src/main.rs b/src/uu/fmt/src/main.rs
index 35531a8b4..7d9bcbd4d 100644
--- a/src/uu/fmt/src/main.rs
+++ b/src/uu/fmt/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_fmt);
+uucore::bin!(uu_fmt);
diff --git a/src/uu/fold/Cargo.toml b/src/uu/fold/Cargo.toml
index ce2aeead4..0ac9a0006 100644
--- a/src/uu/fold/Cargo.toml
+++ b/src/uu/fold/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_fold"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "fold ~ (uutils) wrap each line of input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/fold"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/fold"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/fold.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "fold"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/fold/LICENSE b/src/uu/fold/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/fold/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/fold/src/fold.rs b/src/uu/fold/src/fold.rs
index c4cc16469..d24d31be9 100644
--- a/src/uu/fold/src/fold.rs
+++ b/src/uu/fold/src/fold.rs
@@ -7,19 +7,18 @@
 
 // spell-checker:ignore (ToDOs) ncount routput
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::File;
 use std::io::{stdin, BufRead, BufReader, Read};
 use std::path::Path;
-use uucore::InvalidEncodingHandling;
+use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 const TAB_WIDTH: usize = 8;
 
 static NAME: &str = "fold";
-static SYNTAX: &str = "[OPTION]... [FILE]...";
+static USAGE: &str = "{} [OPTION]... [FILE]...";
 static SUMMARY: &str = "Writes each file (or standard input if no files are given)
  to standard output whilst breaking long lines";
 
@@ -30,7 +29,8 @@ mod options {
     pub const FILE: &str = "file";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -46,10 +46,12 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     };
 
     let width = match poss_width {
-        Some(inp_width) => match inp_width.parse::<usize>() {
-            Ok(width) => width,
-            Err(e) => crash!(1, "illegal width value (\"{}\"): {}", inp_width, e),
-        },
+        Some(inp_width) => inp_width.parse::<usize>().map_err(|e| {
+            USimpleError::new(
+                1,
+                format!("illegal width value ({}): {}", inp_width.quote(), e),
+            )
+        })?,
         None => 80,
     };
 
@@ -58,21 +60,20 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         None => vec!["-".to_owned()],
     };
 
-    fold(files, bytes, spaces, width);
-
-    0
+    fold(&files, bytes, spaces, width)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(SYNTAX)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BYTES)
+            Arg::new(options::BYTES)
                 .long(options::BYTES)
-                .short("b")
+                .short('b')
                 .help(
                     "count using bytes rather than columns (meaning control characters \
                      such as newline are not treated specially)",
@@ -80,22 +81,26 @@ pub fn uu_app() -> App<'static, 'static> {
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::SPACES)
+            Arg::new(options::SPACES)
                 .long(options::SPACES)
-                .short("s")
+                .short('s')
                 .help("break lines at word boundaries rather than a hard cut-off")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::WIDTH)
+            Arg::new(options::WIDTH)
                 .long(options::WIDTH)
-                .short("w")
+                .short('w')
                 .help("set WIDTH as the maximum line width rather than 80")
                 .value_name("WIDTH")
                 .allow_hyphen_values(true)
                 .takes_value(true),
         )
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .arg(
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
 }
 
 fn handle_obsolete(args: &[String]) -> (Vec<String>, Option<String>) {
@@ -110,8 +115,8 @@ fn handle_obsolete(args: &[String]) -> (Vec<String>, Option<String>) {
     (args.to_vec(), None)
 }
 
-fn fold(filenames: Vec<String>, bytes: bool, spaces: bool, width: usize) {
-    for filename in &filenames {
+fn fold(filenames: &[String], bytes: bool, spaces: bool, width: usize) -> UResult<()> {
+    for filename in filenames {
         let filename: &str = filename;
         let mut stdin_buf;
         let mut file_buf;
@@ -119,16 +124,17 @@ fn fold(filenames: Vec<String>, bytes: bool, spaces: bool, width: usize) {
             stdin_buf = stdin();
             &mut stdin_buf as &mut dyn Read
         } else {
-            file_buf = crash_if_err!(1, File::open(Path::new(filename)));
+            file_buf = File::open(Path::new(filename)).map_err_context(|| filename.to_string())?;
             &mut file_buf as &mut dyn Read
         });
 
         if bytes {
-            fold_file_bytewise(buffer, spaces, width);
+            fold_file_bytewise(buffer, spaces, width)?;
         } else {
-            fold_file(buffer, spaces, width);
+            fold_file(buffer, spaces, width)?;
         }
     }
+    Ok(())
 }
 
 /// Fold `file` to fit `width` (number of columns), counting all characters as
@@ -139,11 +145,15 @@ fn fold(filenames: Vec<String>, bytes: bool, spaces: bool, width: usize) {
 /// to all other characters in the stream.
 ///
 ///  If `spaces` is `true`, attempt to break lines at whitespace boundaries.
-fn fold_file_bytewise<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) {
+fn fold_file_bytewise<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) -> UResult<()> {
     let mut line = String::new();
 
     loop {
-        if let Ok(0) = file.read_line(&mut line) {
+        if file
+            .read_line(&mut line)
+            .map_err_context(|| "failed to read line".to_string())?
+            == 0
+        {
             break;
         }
 
@@ -190,6 +200,8 @@ fn fold_file_bytewise<T: Read>(mut file: BufReader<T>, spaces: bool, width: usiz
 
         line.truncate(0);
     }
+
+    Ok(())
 }
 
 /// Fold `file` to fit `width` (number of columns).
@@ -200,7 +212,7 @@ fn fold_file_bytewise<T: Read>(mut file: BufReader<T>, spaces: bool, width: usiz
 ///
 /// If `spaces` is `true`, attempt to break lines at whitespace boundaries.
 #[allow(unused_assignments)]
-fn fold_file<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) {
+fn fold_file<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) -> UResult<()> {
     let mut line = String::new();
     let mut output = String::new();
     let mut col_count = 0;
@@ -230,7 +242,11 @@ fn fold_file<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) {
     }
 
     loop {
-        if let Ok(0) = file.read_line(&mut line) {
+        if file
+            .read_line(&mut line)
+            .map_err_context(|| "failed to read line".to_string())?
+            == 0
+        {
             break;
         }
 
@@ -281,4 +297,6 @@ fn fold_file<T: Read>(mut file: BufReader<T>, spaces: bool, width: usize) {
 
         line.truncate(0);
     }
+
+    Ok(())
 }
diff --git a/src/uu/fold/src/main.rs b/src/uu/fold/src/main.rs
index 1802f2cf8..7658a5d01 100644
--- a/src/uu/fold/src/main.rs
+++ b/src/uu/fold/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_fold);
+uucore::bin!(uu_fold);
diff --git a/src/uu/groups/Cargo.toml b/src/uu/groups/Cargo.toml
index 6ac210692..0eee2a960 100644
--- a/src/uu/groups/Cargo.toml
+++ b/src/uu/groups/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_groups"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "groups ~ (uutils) display group memberships for USERNAME"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/groups"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/groups"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/groups.rs"
 
 [dependencies]
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries", "process"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries", "process"] }
 
 [[bin]]
 name = "groups"
diff --git a/src/uu/groups/LICENSE b/src/uu/groups/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/groups/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/groups/src/groups.rs b/src/uu/groups/src/groups.rs
index 43e2a2239..cd0d05b07 100644
--- a/src/uu/groups/src/groups.rs
+++ b/src/uu/groups/src/groups.rs
@@ -17,12 +17,16 @@
 
 #[macro_use]
 extern crate uucore;
+use std::error::Error;
+use std::fmt::Display;
 use uucore::{
     display::Quotable,
     entries::{get_groups_gnu, gid2grp, Locate, Passwd},
+    error::{UError, UResult},
+    format_usage,
 };
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 
 mod options {
     pub const USERS: &str = "USERNAME";
@@ -31,69 +35,82 @@ static ABOUT: &str = "Print group memberships for each USERNAME or, \
                       if no USERNAME is specified, for\nthe current process \
                       (which may differ if the groups data�base has changed).";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [USERNAME]...", uucore::execution_phrase())
+const USAGE: &str = "{} [OPTION]... [USERNAME]...";
+
+#[derive(Debug)]
+enum GroupsError {
+    GetGroupsFailed,
+    GroupNotFound(u32),
+    UserNotFound(String),
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+impl Error for GroupsError {}
+impl UError for GroupsError {}
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+impl Display for GroupsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::GetGroupsFailed => write!(f, "failed to fetch groups"),
+            Self::GroupNotFound(gid) => write!(f, "cannot find name for group ID {}", gid),
+            Self::UserNotFound(user) => write!(f, "{}: no such user", user.quote()),
+        }
+    }
+}
+
+fn infallible_gid2grp(gid: &u32) -> String {
+    match gid2grp(*gid) {
+        Ok(grp) => grp,
+        Err(_) => {
+            // The `show!()` macro sets the global exit code for the program.
+            show!(GroupsError::GroupNotFound(*gid));
+            gid.to_string()
+        }
+    }
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let users: Vec<String> = matches
         .values_of(options::USERS)
         .map(|v| v.map(ToString::to_string).collect())
         .unwrap_or_default();
 
-    let mut exit_code = 0;
-
     if users.is_empty() {
-        println!(
-            "{}",
-            get_groups_gnu(None)
-                .unwrap()
-                .iter()
-                .map(|&gid| gid2grp(gid).unwrap_or_else(|_| {
-                    show_error!("cannot find name for group ID {}", gid);
-                    exit_code = 1;
-                    gid.to_string()
-                }))
-                .collect::<Vec<_>>()
-                .join(" ")
-        );
-        return exit_code;
+        let gids = match get_groups_gnu(None) {
+            Ok(v) => v,
+            Err(_) => return Err(GroupsError::GetGroupsFailed.into()),
+        };
+        let groups: Vec<String> = gids.iter().map(infallible_gid2grp).collect();
+        println!("{}", groups.join(" "));
+        return Ok(());
     }
 
     for user in users {
-        if let Ok(p) = Passwd::locate(user.as_str()) {
-            println!(
-                "{} : {}",
-                user,
-                p.belongs_to()
-                    .iter()
-                    .map(|&gid| gid2grp(gid).unwrap_or_else(|_| {
-                        show_error!("cannot find name for group ID {}", gid);
-                        exit_code = 1;
-                        gid.to_string()
-                    }))
-                    .collect::<Vec<_>>()
-                    .join(" ")
-            );
-        } else {
-            show_error!("{}: no such user", user.quote());
-            exit_code = 1;
+        match Passwd::locate(user.as_str()) {
+            Ok(p) => {
+                let groups: Vec<String> = p.belongs_to().iter().map(infallible_gid2grp).collect();
+                println!("{} : {}", user, groups.join(" "));
+            }
+            Err(_) => {
+                // The `show!()` macro sets the global exit code for the program.
+                show!(GroupsError::UserNotFound(user));
+            }
         }
     }
-    exit_code
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::USERS)
-                .multiple(true)
+            Arg::new(options::USERS)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .value_name(options::USERS),
         )
diff --git a/src/uu/groups/src/main.rs b/src/uu/groups/src/main.rs
index 6efe64b54..477194fa0 100644
--- a/src/uu/groups/src/main.rs
+++ b/src/uu/groups/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_groups);
+uucore::bin!(uu_groups);
diff --git a/src/uu/hashsum/Cargo.toml b/src/uu/hashsum/Cargo.toml
index 67b0f9e02..6b0181629 100644
--- a/src/uu/hashsum/Cargo.toml
+++ b/src/uu/hashsum/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_hashsum"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hashsum ~ (uutils) display or check input digests"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/hashsum"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/hashsum"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,25 +15,19 @@ edition = "2018"
 path = "src/hashsum.rs"
 
 [dependencies]
-digest = "0.6.1"
-clap = { version = "2.33", features = ["wrap_help"] }
-hex = "0.2.0"
-libc = "0.2.42"
+digest = "0.10.1"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+hex = "0.4.3"
 memchr = "2"
-md5 = "0.3.5"
+md-5 = "0.10.1"
 regex = "1.0.1"
-regex-syntax = "0.6.7"
-sha1 = "0.6.0"
-sha2 = "0.6.0"
-sha3 = "0.6.0"
-blake2b_simd = "0.5.11"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+sha1 = "0.10.1"
+sha2 = "0.10.2"
+sha3 = "0.10.1"
+blake2b_simd = "1.0.0"
+blake3 = "1.3.1"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "hashsum"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/hashsum/LICENSE b/src/uu/hashsum/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/hashsum/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/hashsum/src/digest.rs b/src/uu/hashsum/src/digest.rs
index 61f425662..9220e04a0 100644
--- a/src/uu/hashsum/src/digest.rs
+++ b/src/uu/hashsum/src/digest.rs
@@ -14,12 +14,10 @@ extern crate sha3;
 
 use std::io::Write;
 
-use hex::ToHex;
+use hex::encode;
 #[cfg(windows)]
 use memchr::memmem;
 
-use crate::digest::digest::{ExtendableOutput, Input, XofReader};
-
 pub trait Digest {
     fn new() -> Self
     where
@@ -34,29 +32,7 @@ pub trait Digest {
     fn result_str(&mut self) -> String {
         let mut buf: Vec<u8> = vec![0; self.output_bytes()];
         self.result(&mut buf);
-        buf.to_hex()
-    }
-}
-
-impl Digest for md5::Context {
-    fn new() -> Self {
-        md5::Context::new()
-    }
-
-    fn input(&mut self, input: &[u8]) {
-        self.consume(input)
-    }
-
-    fn result(&mut self, out: &mut [u8]) {
-        out.copy_from_slice(&*self.compute());
-    }
-
-    fn reset(&mut self) {
-        *self = md5::Context::new();
-    }
-
-    fn output_bits(&self) -> usize {
-        128
+        encode(buf)
     }
 }
 
@@ -83,9 +59,9 @@ impl Digest for blake2b_simd::State {
     }
 }
 
-impl Digest for sha1::Sha1 {
+impl Digest for blake3::Hasher {
     fn new() -> Self {
-        sha1::Sha1::new()
+        Self::new()
     }
 
     fn input(&mut self, input: &[u8]) {
@@ -93,20 +69,21 @@ impl Digest for sha1::Sha1 {
     }
 
     fn result(&mut self, out: &mut [u8]) {
-        out.copy_from_slice(&self.digest().bytes());
+        let hash_result = &self.finalize();
+        out.copy_from_slice(hash_result.as_bytes());
     }
 
     fn reset(&mut self) {
-        self.reset();
+        *self = Self::new();
     }
 
     fn output_bits(&self) -> usize {
-        160
+        256
     }
 }
 
 // Implements the Digest trait for sha2 / sha3 algorithms with fixed output
-macro_rules! impl_digest_sha {
+macro_rules! impl_digest_common {
     ($type: ty, $size: expr) => {
         impl Digest for $type {
             fn new() -> Self {
@@ -114,11 +91,11 @@ macro_rules! impl_digest_sha {
             }
 
             fn input(&mut self, input: &[u8]) {
-                digest::Digest::input(self, input);
+                digest::Digest::update(self, input);
             }
 
             fn result(&mut self, out: &mut [u8]) {
-                out.copy_from_slice(digest::Digest::result(*self).as_slice());
+                digest::Digest::finalize_into_reset(self, out.into());
             }
 
             fn reset(&mut self) {
@@ -141,11 +118,11 @@ macro_rules! impl_digest_shake {
             }
 
             fn input(&mut self, input: &[u8]) {
-                self.process(input);
+                digest::Update::update(self, input);
             }
 
             fn result(&mut self, out: &mut [u8]) {
-                self.xof_result().read(out);
+                digest::ExtendableOutputReset::finalize_xof_reset_into(self, out);
             }
 
             fn reset(&mut self) {
@@ -159,15 +136,17 @@ macro_rules! impl_digest_shake {
     };
 }
 
-impl_digest_sha!(sha2::Sha224, 224);
-impl_digest_sha!(sha2::Sha256, 256);
-impl_digest_sha!(sha2::Sha384, 384);
-impl_digest_sha!(sha2::Sha512, 512);
+impl_digest_common!(md5::Md5, 128);
+impl_digest_common!(sha1::Sha1, 160);
+impl_digest_common!(sha2::Sha224, 224);
+impl_digest_common!(sha2::Sha256, 256);
+impl_digest_common!(sha2::Sha384, 384);
+impl_digest_common!(sha2::Sha512, 512);
 
-impl_digest_sha!(sha3::Sha3_224, 224);
-impl_digest_sha!(sha3::Sha3_256, 256);
-impl_digest_sha!(sha3::Sha3_384, 384);
-impl_digest_sha!(sha3::Sha3_512, 512);
+impl_digest_common!(sha3::Sha3_224, 224);
+impl_digest_common!(sha3::Sha3_256, 256);
+impl_digest_common!(sha3::Sha3_384, 384);
+impl_digest_common!(sha3::Sha3_512, 512);
 impl_digest_shake!(sha3::Shake128);
 impl_digest_shake!(sha3::Shake256);
 
@@ -295,7 +274,7 @@ mod tests {
         use crate::digest::DigestWriter;
 
         // Writing "\r" in one call to `write()`, and then "\n" in another.
-        let mut digest = Box::new(md5::Context::new()) as Box<dyn Digest>;
+        let mut digest = Box::new(md5::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();
@@ -303,7 +282,7 @@ mod tests {
         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::Context::new()) as Box<dyn Digest>;
+        let mut digest = Box::new(md5::Md5::new()) as Box<dyn Digest>;
         let mut writer_lf = DigestWriter::new(&mut digest, false);
         writer_lf.write_all(&[b'\n']).unwrap();
         writer_lf.finalize();
diff --git a/src/uu/hashsum/src/hashsum.rs b/src/uu/hashsum/src/hashsum.rs
index 07070ed1b..722585033 100644
--- a/src/uu/hashsum/src/hashsum.rs
+++ b/src/uu/hashsum/src/hashsum.rs
@@ -20,14 +20,15 @@ mod digest;
 use self::digest::Digest;
 use self::digest::DigestWriter;
 
-use clap::{App, Arg, ArgMatches};
-use hex::ToHex;
-use md5::Context as Md5;
+use clap::{Arg, ArgMatches, Command};
+use hex::encode;
+use md5::Md5;
 use regex::Regex;
 use sha1::Sha1;
 use sha2::{Sha224, Sha256, Sha384, Sha512};
 use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
 use std::cmp::Ordering;
+use std::error::Error;
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io::{self, stdin, BufRead, BufReader, Read};
@@ -35,6 +36,7 @@ use std::iter;
 use std::num::ParseIntError;
 use std::path::Path;
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UError, UResult};
 
 const NAME: &str = "hashsum";
 
@@ -68,13 +70,14 @@ fn is_custom_binary(program: &str) -> bool {
             | "shake128sum"
             | "shake256sum"
             | "b2sum"
+            | "b3sum"
     )
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn detect_algo<'a>(
+fn detect_algo(
     program: &str,
-    matches: &ArgMatches<'a>,
+    matches: &ArgMatches,
 ) -> (&'static str, Box<dyn Digest + 'static>, usize) {
     let mut alg: Option<Box<dyn Digest>> = None;
     let mut name: &'static str = "";
@@ -91,6 +94,11 @@ fn detect_algo<'a>(
             Box::new(blake2b_simd::State::new()) as Box<dyn Digest>,
             512,
         ),
+        "b3sum" => (
+            "BLAKE3",
+            Box::new(blake3::Hasher::new()) as Box<dyn Digest>,
+            256,
+        ),
         "sha3sum" => match matches.value_of("bits") {
             Some(bits_str) => match (bits_str).parse::<usize>() {
                 Ok(224) => (
@@ -171,28 +179,31 @@ fn detect_algo<'a>(
                     };
                     name = n;
                     alg = Some(val);
-                    output_bits = bits
+                    output_bits = bits;
                 };
                 if matches.is_present("md5") {
-                    set_or_crash("MD5", Box::new(Md5::new()), 128)
+                    set_or_crash("MD5", Box::new(Md5::new()), 128);
                 }
                 if matches.is_present("sha1") {
-                    set_or_crash("SHA1", Box::new(Sha1::new()), 160)
+                    set_or_crash("SHA1", Box::new(Sha1::new()), 160);
                 }
                 if matches.is_present("sha224") {
-                    set_or_crash("SHA224", Box::new(Sha224::new()), 224)
+                    set_or_crash("SHA224", Box::new(Sha224::new()), 224);
                 }
                 if matches.is_present("sha256") {
-                    set_or_crash("SHA256", Box::new(Sha256::new()), 256)
+                    set_or_crash("SHA256", Box::new(Sha256::new()), 256);
                 }
                 if matches.is_present("sha384") {
-                    set_or_crash("SHA384", Box::new(Sha384::new()), 384)
+                    set_or_crash("SHA384", Box::new(Sha384::new()), 384);
                 }
                 if matches.is_present("sha512") {
-                    set_or_crash("SHA512", Box::new(Sha512::new()), 512)
+                    set_or_crash("SHA512", Box::new(Sha512::new()), 512);
                 }
                 if matches.is_present("b2sum") {
-                    set_or_crash("BLAKE2", Box::new(blake2b_simd::State::new()), 512)
+                    set_or_crash("BLAKE2", Box::new(blake2b_simd::State::new()), 512);
+                }
+                if matches.is_present("b3sum") {
+                    set_or_crash("BLAKE3", Box::new(blake3::Hasher::new()), 256);
                 }
                 if matches.is_present("sha3") {
                     match matches.value_of("bits") {
@@ -227,16 +238,16 @@ fn detect_algo<'a>(
                     }
                 }
                 if matches.is_present("sha3-224") {
-                    set_or_crash("SHA3-224", Box::new(Sha3_224::new()), 224)
+                    set_or_crash("SHA3-224", Box::new(Sha3_224::new()), 224);
                 }
                 if matches.is_present("sha3-256") {
-                    set_or_crash("SHA3-256", Box::new(Sha3_256::new()), 256)
+                    set_or_crash("SHA3-256", Box::new(Sha3_256::new()), 256);
                 }
                 if matches.is_present("sha3-384") {
-                    set_or_crash("SHA3-384", Box::new(Sha3_384::new()), 384)
+                    set_or_crash("SHA3-384", Box::new(Sha3_384::new()), 384);
                 }
                 if matches.is_present("sha3-512") {
-                    set_or_crash("SHA3-512", Box::new(Sha3_512::new()), 512)
+                    set_or_crash("SHA3-512", Box::new(Sha3_512::new()), 512);
                 }
                 if matches.is_present("shake128") {
                     match matches.value_of("bits") {
@@ -268,13 +279,12 @@ fn parse_bit_num(arg: &str) -> Result<usize, ParseIntError> {
     arg.parse()
 }
 
-fn is_valid_bit_num(arg: String) -> Result<(), String> {
-    parse_bit_num(&arg)
-        .map(|_| ())
-        .map_err(|e| format!("{}", e))
+fn is_valid_bit_num(arg: &str) -> Result<(), String> {
+    parse_bit_num(arg).map(|_| ()).map_err(|e| format!("{}", e))
 }
 
-pub fn uumain(mut args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     // if there is no program name for some reason, default to "hashsum"
     let program = args.next().unwrap_or_else(|| OsString::from(NAME));
     let binary_name = Path::new(&program)
@@ -287,13 +297,13 @@ pub fn uumain(mut args: impl uucore::Args) -> i32 {
     // Default binary in Windows, text mode otherwise
     let binary_flag_default = cfg!(windows);
 
-    let app = uu_app(&binary_name);
+    let command = uu_app(&binary_name);
 
-    // FIXME: this should use get_matches_from_safe() and crash!(), but at the moment that just
+    // FIXME: this should use try_get_matches_from() and crash!(), but at the moment that just
     //        causes "error: " to be printed twice (once from crash!() and once from clap).  With
     //        the current setup, the name of the utility is not printed, but I think this is at
     //        least somewhat better from a user's perspective.
-    let matches = app.get_matches_from(args);
+    let matches = command.get_matches_from(args);
 
     let (name, algo, bits) = detect_algo(&binary_name, &matches);
 
@@ -324,18 +334,13 @@ pub fn uumain(mut args: impl uucore::Args) -> i32 {
         warn,
     };
 
-    let res = match matches.values_of_os("FILE") {
+    match matches.values_of_os("FILE") {
         Some(files) => hashsum(opts, files),
         None => hashsum(opts, iter::once(OsStr::new("-"))),
-    };
-
-    match res {
-        Ok(()) => 0,
-        Err(e) => e,
     }
 }
 
-pub fn uu_app_common() -> App<'static, 'static> {
+pub fn uu_app_common<'a>() -> Command<'a> {
     #[cfg(windows)]
     const BINARY_HELP: &str = "read in binary mode (default)";
     #[cfg(not(windows))]
@@ -344,59 +349,60 @@ pub fn uu_app_common() -> App<'static, 'static> {
     const TEXT_HELP: &str = "read in text mode";
     #[cfg(not(windows))]
     const TEXT_HELP: &str = "read in text mode (default)";
-    App::new(uucore::util_name())
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about("Compute and check message digests.")
+        .infer_long_args(true)
         .arg(
-            Arg::with_name("binary")
-                .short("b")
+            Arg::new("binary")
+                .short('b')
                 .long("binary")
                 .help(BINARY_HELP),
         )
         .arg(
-            Arg::with_name("check")
-                .short("c")
+            Arg::new("check")
+                .short('c')
                 .long("check")
                 .help("read hashsums from the FILEs and check them"),
         )
         .arg(
-            Arg::with_name("tag")
+            Arg::new("tag")
                 .long("tag")
                 .help("create a BSD-style checksum"),
         )
         .arg(
-            Arg::with_name("text")
-                .short("t")
+            Arg::new("text")
+                .short('t')
                 .long("text")
                 .help(TEXT_HELP)
                 .conflicts_with("binary"),
         )
         .arg(
-            Arg::with_name("quiet")
-                .short("q")
+            Arg::new("quiet")
+                .short('q')
                 .long("quiet")
                 .help("don't print OK for each successfully verified file"),
         )
         .arg(
-            Arg::with_name("status")
-                .short("s")
+            Arg::new("status")
+                .short('s')
                 .long("status")
                 .help("don't output anything, status code shows success"),
         )
         .arg(
-            Arg::with_name("strict")
+            Arg::new("strict")
                 .long("strict")
                 .help("exit non-zero for improperly formatted checksum lines"),
         )
         .arg(
-            Arg::with_name("warn")
-                .short("w")
+            Arg::new("warn")
+                .short('w')
                 .long("warn")
                 .help("warn about improperly formatted checksum lines"),
         )
         // Needed for variable-length output sums (e.g. SHAKE)
         .arg(
-            Arg::with_name("bits")
+            Arg::new("bits")
                 .long("bits")
                 .help("set the size of the output (only for SHAKE)")
                 .takes_value(true)
@@ -405,15 +411,16 @@ pub fn uu_app_common() -> App<'static, 'static> {
                 .validator(is_valid_bit_num),
         )
         .arg(
-            Arg::with_name("FILE")
+            Arg::new("FILE")
                 .index(1)
-                .multiple(true)
-                .value_name("FILE"),
+                .multiple_occurrences(true)
+                .value_name("FILE")
+                .allow_invalid_utf8(true),
         )
 }
 
-pub fn uu_app_custom() -> App<'static, 'static> {
-    let mut app = uu_app_common();
+pub fn uu_app_custom<'a>() -> Command<'a> {
+    let mut command = uu_app_common();
     let algorithms = &[
         ("md5", "work with MD5"),
         ("sha1", "work with SHA1"),
@@ -435,17 +442,18 @@ pub fn uu_app_custom() -> App<'static, 'static> {
             "work with SHAKE256 using BITS for the output size",
         ),
         ("b2sum", "work with BLAKE2"),
+        ("b3sum", "work with BLAKE3"),
     ];
 
     for (name, desc) in algorithms {
-        app = app.arg(Arg::with_name(name).long(name).help(desc));
+        command = command.arg(Arg::new(*name).long(name).help(*desc));
     }
-    app
+    command
 }
 
 // hashsum is handled differently in build.rs, therefore this is not the same
 // as in other utilities.
-fn uu_app(binary_name: &str) -> App<'static, 'static> {
+fn uu_app<'a>(binary_name: &str) -> Command<'a> {
     if !is_custom_binary(binary_name) {
         uu_app_custom()
     } else {
@@ -453,8 +461,26 @@ fn uu_app(binary_name: &str) -> App<'static, 'static> {
     }
 }
 
+#[derive(Debug)]
+enum HashsumError {
+    InvalidRegex,
+    InvalidFormat,
+}
+
+impl Error for HashsumError {}
+impl UError for HashsumError {}
+
+impl std::fmt::Display for HashsumError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::InvalidRegex => write!(f, "invalid regular expression"),
+            Self::InvalidFormat => Ok(()),
+        }
+    }
+}
+
 #[allow(clippy::cognitive_complexity)]
-fn hashsum<'a, I>(mut options: Options, files: I) -> Result<(), i32>
+fn hashsum<'a, I>(mut options: Options, files: I) -> UResult<()>
 where
     I: Iterator<Item = &'a OsStr>,
 {
@@ -470,7 +496,8 @@ where
             stdin_buf = stdin();
             Box::new(stdin_buf) as Box<dyn Read>
         } else {
-            file_buf = crash_if_err!(1, File::open(filename));
+            file_buf =
+                File::open(filename).map_err_context(|| "failed to open file".to_string())?;
             Box::new(file_buf) as Box<dyn Read>
         });
         if options.check {
@@ -487,25 +514,24 @@ where
             } else {
                 "+".to_string()
             };
-            let gnu_re = crash_if_err!(
-                1,
-                Regex::new(&format!(
-                    r"^(?P<digest>[a-fA-F0-9]{}) (?P<binary>[ \*])(?P<fileName>.*)",
-                    modifier,
-                ))
-            );
-            let bsd_re = crash_if_err!(
-                1,
-                Regex::new(&format!(
-                    r"^{algorithm} \((?P<fileName>.*)\) = (?P<digest>[a-fA-F0-9]{digest_size})",
-                    algorithm = options.algoname,
-                    digest_size = modifier,
-                ))
-            );
+            let gnu_re = Regex::new(&format!(
+                r"^(?P<digest>[a-fA-F0-9]{}) (?P<binary>[ \*])(?P<fileName>.*)",
+                modifier,
+            ))
+            .map_err(|_| HashsumError::InvalidRegex)?;
+            let bsd_re = Regex::new(&format!(
+                r"^{algorithm} \((?P<fileName>.*)\) = (?P<digest>[a-fA-F0-9]{digest_size})",
+                algorithm = options.algoname,
+                digest_size = modifier,
+            ))
+            .map_err(|_| HashsumError::InvalidRegex)?;
 
             let buffer = file;
-            for (i, line) in buffer.lines().enumerate() {
-                let line = crash_if_err!(1, line);
+            for (i, maybe_line) in buffer.lines().enumerate() {
+                let line = match maybe_line {
+                    Ok(l) => l,
+                    Err(e) => return Err(e.map_err_context(|| "failed to read file".to_string())),
+                };
                 let (ck_filename, sum, binary_check) = match gnu_re.captures(&line) {
                     Some(caps) => (
                         caps.name("fileName").unwrap().as_str(),
@@ -521,7 +547,7 @@ where
                         None => {
                             bad_format += 1;
                             if options.strict {
-                                return Err(1);
+                                return Err(HashsumError::InvalidFormat.into());
                             }
                             if options.warn {
                                 show_warning!(
@@ -535,17 +561,16 @@ where
                         }
                     },
                 };
-                let f = crash_if_err!(1, File::open(ck_filename));
+                let f = File::open(ck_filename)
+                    .map_err_context(|| "failed to open file".to_string())?;
                 let mut ckf = BufReader::new(Box::new(f) as Box<dyn Read>);
-                let real_sum = crash_if_err!(
-                    1,
-                    digest_reader(
-                        &mut options.digest,
-                        &mut ckf,
-                        binary_check,
-                        options.output_bits
-                    )
+                let real_sum = digest_reader(
+                    &mut options.digest,
+                    &mut ckf,
+                    binary_check,
+                    options.output_bits,
                 )
+                .map_err_context(|| "failed to read input".to_string())?
                 .to_ascii_lowercase();
                 // FIXME: Filenames with newlines should be treated specially.
                 // GNU appears to replace newlines by \n and backslashes by
@@ -568,15 +593,13 @@ where
                 }
             }
         } else {
-            let sum = crash_if_err!(
-                1,
-                digest_reader(
-                    &mut options.digest,
-                    &mut file,
-                    options.binary,
-                    options.output_bits
-                )
-            );
+            let sum = digest_reader(
+                &mut options.digest,
+                &mut file,
+                options.binary,
+                options.output_bits,
+            )
+            .map_err_context(|| "failed to read input".to_string())?;
             if options.tag {
                 println!("{} ({}) = {}", options.algoname, filename.display(), sum);
             } else {
@@ -629,6 +652,6 @@ fn digest_reader<T: Read>(
         let mut bytes = Vec::new();
         bytes.resize((output_bits + 7) / 8, 0);
         digest.result(&mut bytes);
-        Ok(bytes.to_hex())
+        Ok(encode(bytes))
     }
 }
diff --git a/src/uu/hashsum/src/main.rs b/src/uu/hashsum/src/main.rs
index bc4e2f3be..c31d4a9af 100644
--- a/src/uu/hashsum/src/main.rs
+++ b/src/uu/hashsum/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_hashsum);
+uucore::bin!(uu_hashsum);
diff --git a/src/uu/head/BENCHMARKING.md b/src/uu/head/BENCHMARKING.md
index 49574eb79..29ce4c46b 100644
--- a/src/uu/head/BENCHMARKING.md
+++ b/src/uu/head/BENCHMARKING.md
@@ -20,7 +20,7 @@ and most other parts of the world.
 This particular file has about 170,000 lines, each of which is no longer
 than 96 characters:
 
-    $ wc -lL shakespeare.txt 
+    $ wc -lL shakespeare.txt
     170592      96 shakespeare.txt
 
 You could use files of different shapes and sizes to test the
diff --git a/src/uu/head/Cargo.toml b/src/uu/head/Cargo.toml
index aa32a899a..9159296d2 100644
--- a/src/uu/head/Cargo.toml
+++ b/src/uu/head/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_head"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "head ~ (uutils) display the first lines of input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/head"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/head"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,10 @@ edition = "2018"
 path = "src/head.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 memchr = "2"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["ringbuffer"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] }
 
 [[bin]]
 name = "head"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/head/LICENSE b/src/uu/head/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/head/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/head/src/head.rs b/src/uu/head/src/head.rs
index e3325d084..1ddfc0492 100644
--- a/src/uu/head/src/head.rs
+++ b/src/uu/head/src/head.rs
@@ -3,15 +3,16 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-// spell-checker:ignore (vars) zlines BUFWRITER
+// spell-checker:ignore (vars) zlines BUFWRITER seekable
 
-use clap::{crate_version, App, Arg};
-use std::convert::TryFrom;
+use clap::{crate_version, Arg, ArgMatches, Command};
+use std::convert::{TryFrom, TryInto};
 use std::ffi::OsString;
 use std::io::{self, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write};
 use uucore::display::Quotable;
-use uucore::error::{UResult, USimpleError};
-use uucore::show_error_custom_description;
+use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::lines::lines;
+use uucore::{format_usage, show};
 
 const BUF_SIZE: usize = 65536;
 
@@ -25,7 +26,7 @@ const ABOUT: &str = "\
                      \n\
                      Mandatory arguments to long flags are mandatory for short flags too.\
                      ";
-const USAGE: &str = "head [FLAG]... [FILE]...";
+const USAGE: &str = "{} [FLAG]... [FILE]...";
 
 mod options {
     pub const BYTES_NAME: &str = "BYTES";
@@ -34,22 +35,22 @@ mod options {
     pub const VERBOSE_NAME: &str = "VERBOSE";
     pub const ZERO_NAME: &str = "ZERO";
     pub const FILES_NAME: &str = "FILE";
+    pub const PRESUME_INPUT_PIPE: &str = "-PRESUME-INPUT-PIPE";
 }
-mod lines;
 mod parse;
 mod take;
-use lines::zlines;
 use take::take_all_but;
 use take::take_lines;
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BYTES_NAME)
-                .short("c")
+            Arg::new(options::BYTES_NAME)
+                .short('c')
                 .long("bytes")
                 .value_name("[-]NUM")
                 .takes_value(true)
@@ -64,8 +65,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .allow_hyphen_values(true),
         )
         .arg(
-            Arg::with_name(options::LINES_NAME)
-                .short("n")
+            Arg::new(options::LINES_NAME)
+                .short('n')
                 .long("lines")
                 .value_name("[-]NUM")
                 .takes_value(true)
@@ -80,48 +81,71 @@ pub fn uu_app() -> App<'static, 'static> {
                 .allow_hyphen_values(true),
         )
         .arg(
-            Arg::with_name(options::QUIET_NAME)
-                .short("q")
+            Arg::new(options::QUIET_NAME)
+                .short('q')
                 .long("quiet")
                 .visible_alias("silent")
                 .help("never print headers giving file names")
                 .overrides_with_all(&[options::VERBOSE_NAME, options::QUIET_NAME]),
         )
         .arg(
-            Arg::with_name(options::VERBOSE_NAME)
-                .short("v")
+            Arg::new(options::VERBOSE_NAME)
+                .short('v')
                 .long("verbose")
                 .help("always print headers giving file names")
                 .overrides_with_all(&[options::QUIET_NAME, options::VERBOSE_NAME]),
         )
         .arg(
-            Arg::with_name(options::ZERO_NAME)
-                .short("z")
+            Arg::new(options::PRESUME_INPUT_PIPE)
+                .long("-presume-input-pipe")
+                .alias("-presume-input-pipe")
+                .hide(true),
+        )
+        .arg(
+            Arg::new(options::ZERO_NAME)
+                .short('z')
                 .long("zero-terminated")
                 .help("line delimiter is NUL, not newline")
                 .overrides_with(options::ZERO_NAME),
         )
-        .arg(Arg::with_name(options::FILES_NAME).multiple(true))
-}
-#[derive(PartialEq, Debug, Clone, Copy)]
-enum Modes {
-    Lines(usize),
-    Bytes(usize),
+        .arg(Arg::new(options::FILES_NAME).multiple_occurrences(true))
 }
 
-impl Default for Modes {
+#[derive(Debug, PartialEq)]
+enum Mode {
+    FirstLines(u64),
+    AllButLastLines(u64),
+    FirstBytes(u64),
+    AllButLastBytes(u64),
+}
+
+impl Default for Mode {
     fn default() -> Self {
-        Modes::Lines(10)
+        Self::FirstLines(10)
     }
 }
 
-fn parse_mode<F>(src: &str, closure: F) -> Result<(Modes, bool), String>
-where
-    F: FnOnce(usize) -> Modes,
-{
-    match parse::parse_num(src) {
-        Ok((n, last)) => Ok((closure(n), last)),
-        Err(e) => Err(e.to_string()),
+impl Mode {
+    fn from(matches: &ArgMatches) -> Result<Self, String> {
+        if let Some(v) = matches.value_of(options::BYTES_NAME) {
+            let (n, all_but_last) =
+                parse::parse_num(v).map_err(|err| format!("invalid number of bytes: {}", err))?;
+            if all_but_last {
+                Ok(Self::AllButLastBytes(n))
+            } else {
+                Ok(Self::FirstBytes(n))
+            }
+        } else if let Some(v) = matches.value_of(options::LINES_NAME) {
+            let (n, all_but_last) =
+                parse::parse_num(v).map_err(|err| format!("invalid number of lines: {}", err))?;
+            if all_but_last {
+                Ok(Self::AllButLastLines(n))
+            } else {
+                Ok(Self::FirstLines(n))
+            }
+        } else {
+            Ok(Default::default())
+        }
     }
 }
 
@@ -156,8 +180,8 @@ struct HeadOptions {
     pub quiet: bool,
     pub verbose: bool,
     pub zeroed: bool,
-    pub all_but_last: bool,
-    pub mode: Modes,
+    pub presume_input_pipe: bool,
+    pub mode: Mode,
     pub files: Vec<String>,
 }
 
@@ -166,24 +190,14 @@ impl HeadOptions {
     pub fn get_from(args: impl uucore::Args) -> Result<Self, String> {
         let matches = uu_app().get_matches_from(arg_iterate(args)?);
 
-        let mut options: HeadOptions = Default::default();
+        let mut options = Self::default();
 
         options.quiet = matches.is_present(options::QUIET_NAME);
         options.verbose = matches.is_present(options::VERBOSE_NAME);
         options.zeroed = matches.is_present(options::ZERO_NAME);
+        options.presume_input_pipe = matches.is_present(options::PRESUME_INPUT_PIPE);
 
-        let mode_and_from_end = if let Some(v) = matches.value_of(options::BYTES_NAME) {
-            parse_mode(v, Modes::Bytes)
-                .map_err(|err| format!("invalid number of bytes: {}", err))?
-        } else if let Some(v) = matches.value_of(options::LINES_NAME) {
-            parse_mode(v, Modes::Lines)
-                .map_err(|err| format!("invalid number of lines: {}", err))?
-        } else {
-            (Modes::Lines(10), false)
-        };
-
-        options.mode = mode_and_from_end.0;
-        options.all_but_last = mode_and_from_end.1;
+        options.mode = Mode::from(&matches)?;
 
         options.files = match matches.values_of(options::FILES_NAME) {
             Some(v) => v.map(|s| s.to_owned()).collect(),
@@ -194,12 +208,12 @@ impl HeadOptions {
     }
 }
 
-fn read_n_bytes<R>(input: R, n: usize) -> std::io::Result<()>
+fn read_n_bytes<R>(input: R, n: u64) -> std::io::Result<()>
 where
     R: Read,
 {
     // Read the first `n` bytes from the `input` reader.
-    let mut reader = input.take(n as u64);
+    let mut reader = input.take(n);
 
     // Write those bytes to `stdout`.
     let stdout = std::io::stdout();
@@ -210,7 +224,7 @@ where
     Ok(())
 }
 
-fn read_n_lines(input: &mut impl std::io::BufRead, n: usize, zero: bool) -> std::io::Result<()> {
+fn read_n_lines(input: &mut impl std::io::BufRead, n: u64, zero: bool) -> std::io::Result<()> {
     // Read the first `n` lines from the `input` reader.
     let separator = if zero { b'\0' } else { b'\n' };
     let mut reader = take_lines(input, n, separator);
@@ -228,8 +242,9 @@ fn read_n_lines(input: &mut impl std::io::BufRead, n: usize, zero: bool) -> std:
 fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: usize) -> std::io::Result<()> {
     if n == 0 {
         //prints everything
-        return read_n_bytes(input, std::usize::MAX);
+        return read_n_bytes(input, std::u64::MAX);
     }
+
     let stdout = std::io::stdout();
     let mut stdout = stdout.lock();
 
@@ -280,140 +295,188 @@ fn read_but_last_n_lines(
     if zero {
         let stdout = std::io::stdout();
         let mut stdout = stdout.lock();
-        for bytes in take_all_but(zlines(input), n) {
+        for bytes in take_all_but(lines(input, b'\0'), n) {
             stdout.write_all(&bytes?)?;
         }
     } else {
-        for line in take_all_but(input.lines(), n) {
-            println!("{}", line?);
+        let stdout = std::io::stdout();
+        let mut stdout = stdout.lock();
+        for bytes in take_all_but(lines(input, b'\n'), n) {
+            stdout.write_all(&bytes?)?;
         }
     }
     Ok(())
 }
 
-fn head_backwards_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
-    assert!(options.all_but_last);
+/// Return the index in `input` just after the `n`th line from the end.
+///
+/// If `n` exceeds the number of lines in this file, then return 0.
+///
+/// The cursor must be at the start of the seekable input before
+/// calling this function. This function rewinds the cursor to the
+/// beginning of the input just before returning unless there is an
+/// I/O error.
+///
+/// If `zeroed` is `false`, interpret the newline character `b'\n'` as
+/// a line ending. If `zeroed` is `true`, interpret the null character
+/// `b'\0'` as a line ending instead.
+///
+/// # Errors
+///
+/// This function returns an error if there is a problem seeking
+/// through or reading the input.
+///
+/// # Examples
+///
+/// The function returns the index of the byte immediately following
+/// the line ending character of the `n`th line from the end of the
+/// input:
+///
+/// ```rust,ignore
+/// let mut input = Cursor::new("x\ny\nz\n");
+/// assert_eq!(find_nth_line_from_end(&mut input, 0, false).unwrap(), 6);
+/// assert_eq!(find_nth_line_from_end(&mut input, 1, false).unwrap(), 4);
+/// assert_eq!(find_nth_line_from_end(&mut input, 2, false).unwrap(), 2);
+/// ```
+///
+/// If `n` exceeds the number of lines in the file, always return 0:
+///
+/// ```rust,ignore
+/// let mut input = Cursor::new("x\ny\nz\n");
+/// assert_eq!(find_nth_line_from_end(&mut input, 3, false).unwrap(), 0);
+/// assert_eq!(find_nth_line_from_end(&mut input, 4, false).unwrap(), 0);
+/// assert_eq!(find_nth_line_from_end(&mut input, 1000, false).unwrap(), 0);
+/// ```
+fn find_nth_line_from_end<R>(input: &mut R, n: u64, zeroed: bool) -> std::io::Result<u64>
+where
+    R: Read + Seek,
+{
     let size = input.seek(SeekFrom::End(0))?;
-    let size = usize::try_from(size).unwrap();
+
+    let mut buffer = [0u8; BUF_SIZE];
+    let buf_size: usize = (BUF_SIZE as u64).min(size).try_into().unwrap();
+    let buffer = &mut buffer[..buf_size];
+
+    let mut i = 0u64;
+    let mut lines = 0u64;
+
+    loop {
+        // the casts here are ok, `buffer.len()` should never be above a few k
+        input.seek(SeekFrom::Current(
+            -((buffer.len() as i64).min((size - i) as i64)),
+        ))?;
+        input.read_exact(buffer)?;
+        for byte in buffer.iter().rev() {
+            match byte {
+                b'\n' if !zeroed => {
+                    lines += 1;
+                }
+                0u8 if zeroed => {
+                    lines += 1;
+                }
+                _ => {}
+            }
+            // if it were just `n`,
+            if lines == n + 1 {
+                input.seek(SeekFrom::Start(0))?;
+                return Ok(size - i);
+            }
+            i += 1;
+        }
+        if size - i == 0 {
+            input.seek(SeekFrom::Start(0))?;
+            return Ok(0);
+        }
+    }
+}
+
+fn head_backwards_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
     match options.mode {
-        Modes::Bytes(n) => {
+        Mode::AllButLastBytes(n) => {
+            let size = input.metadata()?.len();
             if n >= size {
                 return Ok(());
             } else {
-                input.seek(SeekFrom::Start(0))?;
                 read_n_bytes(
                     &mut std::io::BufReader::with_capacity(BUF_SIZE, input),
                     size - n,
                 )?;
             }
         }
-        Modes::Lines(n) => {
-            let mut buffer = [0u8; BUF_SIZE];
-            let buffer = &mut buffer[..BUF_SIZE.min(size)];
-            let mut i = 0usize;
-            let mut lines = 0usize;
-
-            let found = 'o: loop {
-                // the casts here are ok, `buffer.len()` should never be above a few k
-                input.seek(SeekFrom::Current(
-                    -((buffer.len() as i64).min((size - i) as i64)),
-                ))?;
-                input.read_exact(buffer)?;
-                for byte in buffer.iter().rev() {
-                    match byte {
-                        b'\n' if !options.zeroed => {
-                            lines += 1;
-                        }
-                        0u8 if options.zeroed => {
-                            lines += 1;
-                        }
-                        _ => {}
-                    }
-                    // if it were just `n`,
-                    if lines == n + 1 {
-                        break 'o i;
-                    }
-                    i += 1;
-                }
-                if size - i == 0 {
-                    return Ok(());
-                }
-            };
-            input.seek(SeekFrom::Start(0))?;
+        Mode::AllButLastLines(n) => {
+            let found = find_nth_line_from_end(input, n, options.zeroed)?;
             read_n_bytes(
                 &mut std::io::BufReader::with_capacity(BUF_SIZE, input),
-                size - found,
+                found,
             )?;
         }
+        _ => unreachable!(),
     }
     Ok(())
 }
 
 fn head_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
-    if options.all_but_last {
-        head_backwards_file(input, options)
-    } else {
-        match options.mode {
-            Modes::Bytes(n) => {
-                read_n_bytes(&mut std::io::BufReader::with_capacity(BUF_SIZE, input), n)
-            }
-            Modes::Lines(n) => read_n_lines(
-                &mut std::io::BufReader::with_capacity(BUF_SIZE, input),
-                n,
-                options.zeroed,
-            ),
+    match options.mode {
+        Mode::FirstBytes(n) => {
+            read_n_bytes(&mut std::io::BufReader::with_capacity(BUF_SIZE, input), n)
         }
+        Mode::FirstLines(n) => read_n_lines(
+            &mut std::io::BufReader::with_capacity(BUF_SIZE, input),
+            n,
+            options.zeroed,
+        ),
+        Mode::AllButLastBytes(_) | Mode::AllButLastLines(_) => head_backwards_file(input, options),
     }
 }
 
 fn uu_head(options: &HeadOptions) -> UResult<()> {
-    let mut error_count = 0;
     let mut first = true;
     for file in &options.files {
-        let res = match file.as_str() {
-            "-" => {
+        let res = match (file.as_str(), options.presume_input_pipe) {
+            (_, true) | ("-", false) => {
                 if (options.files.len() > 1 && !options.quiet) || options.verbose {
                     if !first {
                         println!();
                     }
-                    println!("==> standard input <==")
+                    println!("==> standard input <==");
                 }
                 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!("{}: number of bytes is too large", e)
+                        ));
+                        continue;
+                    };
+                };
+
                 match options.mode {
-                    Modes::Bytes(n) => {
-                        if options.all_but_last {
-                            read_but_last_n_bytes(&mut stdin, n)
-                        } else {
-                            read_n_bytes(&mut stdin, n)
-                        }
+                    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())
                     }
-                    Modes::Lines(n) => {
-                        if options.all_but_last {
-                            read_but_last_n_lines(&mut stdin, n, options.zeroed)
-                        } else {
-                            read_n_lines(&mut stdin, n, options.zeroed)
-                        }
+                    Mode::FirstLines(n) => read_n_lines(&mut stdin, n, options.zeroed),
+                    // 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.zeroed)
                     }
                 }
             }
-            name => {
+            (name, false) => {
                 let mut file = match std::fs::File::open(name) {
                     Ok(f) => f,
                     Err(err) => {
-                        let prefix = format!("cannot open {} for reading", name.quote());
-                        match err.kind() {
-                            ErrorKind::NotFound => {
-                                show_error_custom_description!(prefix, "No such file or directory");
-                            }
-                            ErrorKind::PermissionDenied => {
-                                show_error_custom_description!(prefix, "Permission denied");
-                            }
-                            _ => {
-                                show_error_custom_description!(prefix, "{}", err);
-                            }
-                        }
-                        error_count += 1;
+                        show!(err.map_err_context(|| format!(
+                            "cannot open {} for reading",
+                            name.quote()
+                        )));
                         continue;
                     }
                 };
@@ -421,7 +484,7 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
                     if !first {
                         println!();
                     }
-                    println!("==> {} <==", name)
+                    println!("==> {} <==", name);
                 }
                 head_file(&mut file, options)
             }
@@ -432,20 +495,21 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
             } else {
                 file
             };
-            let prefix = format!("error reading {}", name);
-            show_error_custom_description!(prefix, "Input/output error");
-            error_count += 1;
+            show!(USimpleError::new(
+                1,
+                format!("error reading {}: Input/output error", name)
+            ));
         }
         first = false;
     }
-    if error_count > 0 {
-        Err(USimpleError::new(1, ""))
-    } else {
-        Ok(())
-    }
+    // Even though this is returning `Ok`, it is possible that a call
+    // to `show!()` and thus a call to `set_exit_code()` has been
+    // called above. If that happens, then this process will exit with
+    // a non-zero exit code.
+    Ok(())
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = match HeadOptions::get_from(args) {
         Ok(o) => o,
@@ -459,6 +523,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 #[cfg(test)]
 mod tests {
     use std::ffi::OsString;
+    use std::io::Cursor;
 
     use super::*;
     fn options(args: &str) -> Result<HeadOptions, String> {
@@ -471,17 +536,16 @@ mod tests {
         let args = options("-n -10M -vz").unwrap();
         assert!(args.zeroed);
         assert!(args.verbose);
-        assert!(args.all_but_last);
-        assert_eq!(args.mode, Modes::Lines(10 * 1024 * 1024));
+        assert_eq!(args.mode, Mode::AllButLastLines(10 * 1024 * 1024));
     }
     #[test]
     fn test_gnu_compatibility() {
         let args = options("-n 1 -c 1 -n 5 -c kiB -vqvqv").unwrap(); // spell-checker:disable-line
-        assert!(args.mode == Modes::Bytes(1024));
+        assert!(args.mode == Mode::FirstBytes(1024));
         assert!(args.verbose);
-        assert_eq!(options("-5").unwrap().mode, Modes::Lines(5));
-        assert_eq!(options("-2b").unwrap().mode, Modes::Bytes(1024));
-        assert_eq!(options("-5 -c 1").unwrap().mode, Modes::Bytes(1));
+        assert_eq!(options("-5").unwrap().mode, Mode::FirstLines(5));
+        assert_eq!(options("-2b").unwrap().mode, Mode::FirstBytes(1024));
+        assert_eq!(options("-5 -c 1").unwrap().mode, Mode::FirstBytes(1));
     }
     #[test]
     fn all_args_test() {
@@ -492,10 +556,10 @@ mod tests {
         assert!(options("-v").unwrap().verbose);
         assert!(options("--zero-terminated").unwrap().zeroed);
         assert!(options("-z").unwrap().zeroed);
-        assert_eq!(options("--lines 15").unwrap().mode, Modes::Lines(15));
-        assert_eq!(options("-n 15").unwrap().mode, Modes::Lines(15));
-        assert_eq!(options("--bytes 15").unwrap().mode, Modes::Bytes(15));
-        assert_eq!(options("-c 15").unwrap().mode, Modes::Bytes(15));
+        assert_eq!(options("--lines 15").unwrap().mode, Mode::FirstLines(15));
+        assert_eq!(options("-n 15").unwrap().mode, Mode::FirstLines(15));
+        assert_eq!(options("--bytes 15").unwrap().mode, Mode::FirstBytes(15));
+        assert_eq!(options("-c 15").unwrap().mode, Mode::FirstBytes(15));
     }
     #[test]
     fn test_options_errors() {
@@ -509,26 +573,9 @@ mod tests {
         assert!(!opts.verbose);
         assert!(!opts.quiet);
         assert!(!opts.zeroed);
-        assert!(!opts.all_but_last);
-        assert_eq!(opts.mode, Modes::Lines(10));
+        assert_eq!(opts.mode, Mode::FirstLines(10));
         assert!(opts.files.is_empty());
     }
-    #[test]
-    fn test_parse_mode() {
-        assert_eq!(
-            parse_mode("123", Modes::Lines),
-            Ok((Modes::Lines(123), false))
-        );
-        assert_eq!(
-            parse_mode("-456", Modes::Bytes),
-            Ok((Modes::Bytes(456), true))
-        );
-        assert!(parse_mode("Nonsensical Nonsense", Modes::Bytes).is_err());
-        #[cfg(target_pointer_width = "64")]
-        assert!(parse_mode("1Y", Modes::Lines).is_err());
-        #[cfg(target_pointer_width = "32")]
-        assert!(parse_mode("1T", Modes::Bytes).is_err());
-    }
     fn arg_outputs(src: &str) -> Result<String, String> {
         let split = src.split_whitespace().map(OsString::from);
         match arg_iterate(split) {
@@ -580,4 +627,15 @@ mod tests {
         assert!(read_n_bytes(&mut empty, 0).is_ok());
         assert!(read_n_lines(&mut empty, 0, false).is_ok());
     }
+
+    #[test]
+    fn test_find_nth_line_from_end() {
+        let mut input = Cursor::new("x\ny\nz\n");
+        assert_eq!(find_nth_line_from_end(&mut input, 0, false).unwrap(), 6);
+        assert_eq!(find_nth_line_from_end(&mut input, 1, false).unwrap(), 4);
+        assert_eq!(find_nth_line_from_end(&mut input, 2, false).unwrap(), 2);
+        assert_eq!(find_nth_line_from_end(&mut input, 3, false).unwrap(), 0);
+        assert_eq!(find_nth_line_from_end(&mut input, 4, false).unwrap(), 0);
+        assert_eq!(find_nth_line_from_end(&mut input, 1000, false).unwrap(), 0);
+    }
 }
diff --git a/src/uu/head/src/lines.rs b/src/uu/head/src/lines.rs
deleted file mode 100644
index 118aba17f..000000000
--- a/src/uu/head/src/lines.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-// spell-checker:ignore (vars) zline zlines
-
-//! Iterate over zero-terminated lines.
-use std::io::BufRead;
-
-/// The zero byte, representing the null character.
-const ZERO: u8 = 0;
-
-/// Returns an iterator over the lines of the given reader.
-///
-/// The iterator returned from this function will yield instances of
-/// [`io::Result`]<[`Vec`]<[`u8`]>>, representing the bytes of the line
-/// *including* the null character (with the possible exception of the
-/// last line, which may not have one).
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// use std::io::Cursor;
-///
-/// let cursor = Cursor::new(b"x\0y\0z\0");
-/// let mut iter = zlines(cursor).map(|l| l.unwrap());
-/// assert_eq!(iter.next(), Some(b"x\0".to_vec()));
-/// assert_eq!(iter.next(), Some(b"y\0".to_vec()));
-/// assert_eq!(iter.next(), Some(b"z\0".to_vec()));
-/// assert_eq!(iter.next(), None);
-/// ```
-pub fn zlines<B>(buf: B) -> ZLines<B> {
-    ZLines { buf }
-}
-
-/// An iterator over the zero-terminated lines of an instance of `BufRead`.
-pub struct ZLines<B> {
-    buf: B,
-}
-
-impl<B: BufRead> Iterator for ZLines<B> {
-    type Item = std::io::Result<Vec<u8>>;
-
-    fn next(&mut self) -> Option<std::io::Result<Vec<u8>>> {
-        let mut buf = Vec::new();
-        match self.buf.read_until(ZERO, &mut buf) {
-            Ok(0) => None,
-            Ok(_) => Some(Ok(buf)),
-            Err(e) => Some(Err(e)),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::lines::zlines;
-    use std::io::Cursor;
-
-    #[test]
-    fn test_null_terminated() {
-        let cursor = Cursor::new(b"x\0y\0z\0");
-        let mut iter = zlines(cursor).map(|l| l.unwrap());
-        assert_eq!(iter.next(), Some(b"x\0".to_vec()));
-        assert_eq!(iter.next(), Some(b"y\0".to_vec()));
-        assert_eq!(iter.next(), Some(b"z\0".to_vec()));
-        assert_eq!(iter.next(), None);
-    }
-
-    #[test]
-    fn test_not_null_terminated() {
-        let cursor = Cursor::new(b"x\0y\0z");
-        let mut iter = zlines(cursor).map(|l| l.unwrap());
-        assert_eq!(iter.next(), Some(b"x\0".to_vec()));
-        assert_eq!(iter.next(), Some(b"y\0".to_vec()));
-        assert_eq!(iter.next(), Some(b"z".to_vec()));
-        assert_eq!(iter.next(), None);
-    }
-}
diff --git a/src/uu/head/src/main.rs b/src/uu/head/src/main.rs
index 3e66a50d0..850a725e4 100644
--- a/src/uu/head/src/main.rs
+++ b/src/uu/head/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_head);
+uucore::bin!(uu_head);
diff --git a/src/uu/head/src/parse.rs b/src/uu/head/src/parse.rs
index f6f291814..ee543fe06 100644
--- a/src/uu/head/src/parse.rs
+++ b/src/uu/head/src/parse.rs
@@ -12,7 +12,7 @@ pub enum ParseError {
     Overflow,
 }
 /// Parses obsolete syntax
-/// head -NUM[kmzv] // spell-checker:disable-line
+/// head -NUM\[kmzv\] // spell-checker:disable-line
 pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>, ParseError>> {
     let mut chars = src.char_indices();
     if let Some((_, '-')) = chars.next() {
@@ -20,7 +20,7 @@ pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>
         let mut has_num = false;
         let mut last_char = 0 as char;
         for (n, c) in &mut chars {
-            if c.is_numeric() {
+            if c.is_digit(10) {
                 has_num = true;
                 num_end = n;
             } else {
@@ -43,11 +43,11 @@ pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>
                             // this also saves us 1 heap allocation
                             'q' => {
                                 quiet = true;
-                                verbose = false
+                                verbose = false;
                             }
                             'v' => {
                                 verbose = true;
-                                quiet = false
+                                quiet = false;
                             }
                             'z' => zero_terminated = true,
                             'c' => multiplier = Some(1),
@@ -58,20 +58,20 @@ pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>
                             _ => return Some(Err(ParseError::Syntax)),
                         }
                         if let Some((_, next)) = chars.next() {
-                            c = next
+                            c = next;
                         } else {
                             break;
                         }
                     }
                     let mut options = Vec::new();
                     if quiet {
-                        options.push(OsString::from("-q"))
+                        options.push(OsString::from("-q"));
                     }
                     if verbose {
-                        options.push(OsString::from("-v"))
+                        options.push(OsString::from("-v"));
                     }
                     if zero_terminated {
-                        options.push(OsString::from("-z"))
+                        options.push(OsString::from("-z"));
                     }
                     if let Some(n) = multiplier {
                         options.push(OsString::from("-c"));
@@ -97,7 +97,7 @@ pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>
 }
 /// Parses an -c or -n argument,
 /// the bool specifies whether to read from the end
-pub fn parse_num(src: &str) -> Result<(usize, bool), ParseSizeError> {
+pub fn parse_num(src: &str) -> Result<(u64, bool), ParseSizeError> {
     let mut size_string = src.trim();
     let mut all_but_last = false;
 
diff --git a/src/uu/head/src/take.rs b/src/uu/head/src/take.rs
index 5f4c29b65..47beba8a4 100644
--- a/src/uu/head/src/take.rs
+++ b/src/uu/head/src/take.rs
@@ -28,7 +28,7 @@ pub struct TakeAllBut<I: Iterator> {
 }
 
 impl<I: Iterator> TakeAllBut<I> {
-    pub fn new(mut iter: I, n: usize) -> TakeAllBut<I> {
+    pub fn new(mut iter: I, n: usize) -> Self {
         // Create a new ring buffer and fill it up.
         //
         // If there are fewer than `n` elements in `iter`, then we
@@ -44,7 +44,7 @@ impl<I: Iterator> TakeAllBut<I> {
             };
             buf.push_back(value);
         }
-        TakeAllBut { iter, buf }
+        Self { iter, buf }
     }
 }
 
@@ -65,11 +65,11 @@ where
 /// Like `std::io::Take`, but for lines instead of bytes.
 ///
 /// This struct is generally created by calling [`take_lines`] on a
-/// reader. Please see the documentation of [`take`] for more
+/// reader. Please see the documentation of [`take_lines`] for more
 /// details.
 pub struct TakeLines<T> {
     inner: T,
-    limit: usize,
+    limit: u64,
     separator: u8,
 }
 
@@ -103,7 +103,7 @@ impl<T: Read> Read for TakeLines<T> {
 ///
 /// The `separator` defines the character to interpret as the line
 /// ending. For the usual notion of "line", set this to `b'\n'`.
-pub fn take_lines<R>(reader: R, limit: usize, separator: u8) -> TakeLines<R> {
+pub fn take_lines<R>(reader: R, limit: u64, separator: u8) -> TakeLines<R> {
     TakeLines {
         inner: reader,
         limit,
diff --git a/src/uu/hostid/Cargo.toml b/src/uu/hostid/Cargo.toml
index c56649742..6449684f6 100644
--- a/src/uu/hostid/Cargo.toml
+++ b/src/uu/hostid/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_hostid"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hostid ~ (uutils) display the numeric identifier of the current host"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/hostid"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/hostid"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/hostid.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "hostid"
diff --git a/src/uu/hostid/LICENSE b/src/uu/hostid/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/hostid/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/hostid/src/hostid.rs b/src/uu/hostid/src/hostid.rs
index 309e15990..b60446e9f 100644
--- a/src/uu/hostid/src/hostid.rs
+++ b/src/uu/hostid/src/hostid.rs
@@ -7,28 +7,31 @@
 
 // spell-checker:ignore (ToDO) gethostid
 
-use clap::{crate_version, App};
+use clap::{crate_version, Command};
 use libc::c_long;
-use uucore::error::UResult;
+use uucore::{error::UResult, format_usage};
 
-static SYNTAX: &str = "[options]";
+const USAGE: &str = "{} [options]";
+const SUMMARY: &str = "Print the numeric identifier (in hexadecimal) for the current host";
 
 // currently rust libc interface doesn't include gethostid
 extern "C" {
     pub fn gethostid() -> c_long;
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     uu_app().get_matches_from(args);
     hostid();
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
-        .usage(SYNTAX)
+        .about(SUMMARY)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
 }
 
 fn hostid() {
diff --git a/src/uu/hostid/src/main.rs b/src/uu/hostid/src/main.rs
index 9645ed4a6..de9e22fbf 100644
--- a/src/uu/hostid/src/main.rs
+++ b/src/uu/hostid/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_hostid);
+uucore::bin!(uu_hostid);
diff --git a/src/uu/hostname/Cargo.toml b/src/uu/hostname/Cargo.toml
index daaeb48f7..0ff8f2f4d 100644
--- a/src/uu/hostname/Cargo.toml
+++ b/src/uu/hostname/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_hostname"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "hostname ~ (uutils) display or set the host name of the current host"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/hostname"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/hostname"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,13 +15,14 @@ edition = "2018"
 path = "src/hostname.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 hostname = { version = "0.3", features = ["set"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["wide"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["wide"] }
 winapi = { version="0.3", features=["sysinfoapi", "winsock2"] }
 
 [[bin]]
 name = "hostname"
 path = "src/main.rs"
+
+[package.metadata.cargo-udeps.ignore]
+normal = ["uucore_procs", "winapi"]
diff --git a/src/uu/hostname/LICENSE b/src/uu/hostname/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/hostname/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/hostname/src/hostname.rs b/src/uu/hostname/src/hostname.rs
index 9c8504027..757caed02 100644
--- a/src/uu/hostname/src/hostname.rs
+++ b/src/uu/hostname/src/hostname.rs
@@ -11,11 +11,15 @@ use std::collections::hash_set::HashSet;
 use std::net::ToSocketAddrs;
 use std::str;
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 
-use uucore::error::{FromIo, UResult};
+use uucore::{
+    error::{FromIo, UResult},
+    format_usage,
+};
 
 static ABOUT: &str = "Display or set the system's host name.";
+const USAGE: &str = "{} [OPTION]... [HOSTNAME]";
 
 static OPT_DOMAIN: &str = "domain";
 static OPT_IP_ADDRESS: &str = "ip-address";
@@ -54,14 +58,9 @@ mod wsa {
     }
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [HOSTNAME]", uucore::execution_phrase())
-}
-
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     #[cfg(windows)]
     let _handle = wsa::start().map_err_context(|| "failed to start Winsock".to_owned())?;
@@ -72,39 +71,41 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_DOMAIN)
-                .short("d")
+            Arg::new(OPT_DOMAIN)
+                .short('d')
                 .long("domain")
                 .overrides_with_all(&[OPT_DOMAIN, OPT_IP_ADDRESS, OPT_FQDN, OPT_SHORT])
                 .help("Display the name of the DNS domain if possible"),
         )
         .arg(
-            Arg::with_name(OPT_IP_ADDRESS)
-                .short("i")
+            Arg::new(OPT_IP_ADDRESS)
+                .short('i')
                 .long("ip-address")
                 .overrides_with_all(&[OPT_DOMAIN, OPT_IP_ADDRESS, OPT_FQDN, OPT_SHORT])
                 .help("Display the network address(es) of the host"),
         )
         .arg(
-            Arg::with_name(OPT_FQDN)
-                .short("f")
+            Arg::new(OPT_FQDN)
+                .short('f')
                 .long("fqdn")
                 .overrides_with_all(&[OPT_DOMAIN, OPT_IP_ADDRESS, OPT_FQDN, OPT_SHORT])
                 .help("Display the FQDN (Fully Qualified Domain Name) (default)"),
         )
         .arg(
-            Arg::with_name(OPT_SHORT)
-                .short("s")
+            Arg::new(OPT_SHORT)
+                .short('s')
                 .long("short")
                 .overrides_with_all(&[OPT_DOMAIN, OPT_IP_ADDRESS, OPT_FQDN, OPT_SHORT])
                 .help("Display the short hostname (the portion before the first dot) if possible"),
         )
-        .arg(Arg::with_name(OPT_HOST))
+        .arg(Arg::new(OPT_HOST).allow_invalid_utf8(true))
 }
 
 fn display_hostname(matches: &ArgMatches) -> UResult<()> {
diff --git a/src/uu/hostname/src/main.rs b/src/uu/hostname/src/main.rs
index 1d6e6733e..09058e44a 100644
--- a/src/uu/hostname/src/main.rs
+++ b/src/uu/hostname/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_hostname);
+uucore::bin!(uu_hostname);
diff --git a/src/uu/id/Cargo.toml b/src/uu/id/Cargo.toml
index 0039cfc8e..332ba9ca6 100644
--- a/src/uu/id/Cargo.toml
+++ b/src/uu/id/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_id"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "id ~ (uutils) display user and group information for USER"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/id"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/id"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/id.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries", "process"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-selinux = { version="0.2.1", optional = true }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries", "process"] }
+selinux = { version="0.2", optional = true }
 
 [[bin]]
 name = "id"
diff --git a/src/uu/id/LICENSE b/src/uu/id/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/id/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/id/src/id.rs b/src/uu/id/src/id.rs
index 1229b577e..3bb9ce8c9 100644
--- a/src/uu/id/src/id.rs
+++ b/src/uu/id/src/id.rs
@@ -39,12 +39,13 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::ffi::CStr;
 use uucore::display::Quotable;
 use uucore::entries::{self, Group, Locate, Passwd};
 use uucore::error::UResult;
 use uucore::error::{set_exit_code, USimpleError};
+use uucore::format_usage;
 pub use uucore::libc;
 use uucore::libc::{getlogin, uid_t};
 use uucore::process::{getegid, geteuid, getgid, getuid};
@@ -57,6 +58,7 @@ macro_rules! cstr2cow {
 
 static ABOUT: &str = "Print user and group information for each specified USER,
 or (when USER omitted) for the current user.";
+const USAGE: &str = "{} [OPTION]... [USER]...";
 
 #[cfg(not(feature = "selinux"))]
 static CONTEXT_HELP_TEXT: &str = "print only the security context of the process (not enabled)";
@@ -77,10 +79,6 @@ mod options {
     pub const ARG_USERS: &str = "USER";
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [USER]...", uucore::execution_phrase())
-}
-
 fn get_description() -> String {
     String::from(
         "The id utility displays the user and group names and numeric IDs, of the \
@@ -126,15 +124,11 @@ struct State {
     user_specified: bool,
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
     let after_help = get_description();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let users: Vec<String> = matches
         .values_of(options::ARG_USERS)
@@ -245,7 +239,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         // GNU's `id` does not support the flags: -p/-P/-A.
         if matches.is_present(options::OPT_PASSWORD) {
             // BSD's `id` ignores all but the first specified user
-            pline(possible_pw.map(|v| v.uid()));
+            pline(possible_pw.as_ref().map(|v| v.uid));
             return Ok(());
         };
         if matches.is_present(options::OPT_HUMAN_READABLE) {
@@ -259,7 +253,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             return Ok(());
         }
 
-        let (uid, gid) = possible_pw.map(|p| (p.uid(), p.gid())).unwrap_or((
+        let (uid, gid) = possible_pw.as_ref().map(|p| (p.uid, p.gid)).unwrap_or((
             if state.rflag { getuid() } else { geteuid() },
             if state.rflag { getgid() } else { getegid() },
         ));
@@ -302,7 +296,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
         let groups = entries::get_groups_gnu(Some(gid)).unwrap();
         let groups = if state.user_specified {
-            possible_pw.map(|p| p.belongs_to()).unwrap()
+            possible_pw.as_ref().map(|p| p.belongs_to()).unwrap()
         } else {
             groups.clone()
         };
@@ -335,7 +329,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
 
         if default_format {
-            id_print(&mut state, groups);
+            id_print(&mut state, &groups);
         }
         print!("{}", line_ending);
 
@@ -347,13 +341,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::OPT_AUDIT)
-                .short("A")
+            Arg::new(options::OPT_AUDIT)
+                .short('A')
                 .conflicts_with_all(&[
                     options::OPT_GROUP,
                     options::OPT_EFFECTIVE_USER,
@@ -368,22 +364,22 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::OPT_EFFECTIVE_USER)
-                .short("u")
+            Arg::new(options::OPT_EFFECTIVE_USER)
+                .short('u')
                 .long(options::OPT_EFFECTIVE_USER)
                 .conflicts_with(options::OPT_GROUP)
                 .help("Display only the effective user ID as a number."),
         )
         .arg(
-            Arg::with_name(options::OPT_GROUP)
-                .short("g")
+            Arg::new(options::OPT_GROUP)
+                .short('g')
                 .long(options::OPT_GROUP)
                 .conflicts_with(options::OPT_EFFECTIVE_USER)
                 .help("Display only the effective group ID as a number"),
         )
         .arg(
-            Arg::with_name(options::OPT_GROUPS)
-                .short("G")
+            Arg::new(options::OPT_GROUPS)
+                .short('G')
                 .long(options::OPT_GROUPS)
                 .conflicts_with_all(&[
                     options::OPT_GROUP,
@@ -399,13 +395,13 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::OPT_HUMAN_READABLE)
-                .short("p")
+            Arg::new(options::OPT_HUMAN_READABLE)
+                .short('p')
                 .help("Make the output human-readable. Each display is on a separate line."),
         )
         .arg(
-            Arg::with_name(options::OPT_NAME)
-                .short("n")
+            Arg::new(options::OPT_NAME)
+                .short('n')
                 .long(options::OPT_NAME)
                 .help(
                     "Display the name of the user or group ID for the -G, -g and -u options \
@@ -414,13 +410,13 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::OPT_PASSWORD)
-                .short("P")
+            Arg::new(options::OPT_PASSWORD)
+                .short('P')
                 .help("Display the id as a password file entry."),
         )
         .arg(
-            Arg::with_name(options::OPT_REAL_ID)
-                .short("r")
+            Arg::new(options::OPT_REAL_ID)
+                .short('r')
                 .long(options::OPT_REAL_ID)
                 .help(
                     "Display the real ID for the -G, -g and -u options instead of \
@@ -428,8 +424,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::OPT_ZERO)
-                .short("z")
+            Arg::new(options::OPT_ZERO)
+                .short('z')
                 .long(options::OPT_ZERO)
                 .help(
                     "delimit entries with NUL characters, not whitespace;\n\
@@ -437,15 +433,15 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::OPT_CONTEXT)
-                .short("Z")
+            Arg::new(options::OPT_CONTEXT)
+                .short('Z')
                 .long(options::OPT_CONTEXT)
                 .conflicts_with_all(&[options::OPT_GROUP, options::OPT_EFFECTIVE_USER])
                 .help(CONTEXT_HELP_TEXT),
         )
         .arg(
-            Arg::with_name(options::ARG_USERS)
-                .multiple(true)
+            Arg::new(options::ARG_USERS)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .value_name(options::ARG_USERS),
         )
@@ -453,7 +449,7 @@ pub fn uu_app() -> App<'static, 'static> {
 
 fn pretty(possible_pw: Option<Passwd>) {
     if let Some(p) = possible_pw {
-        print!("uid\t{}\ngroups\t", p.name());
+        print!("uid\t{}\ngroups\t", p.name);
         println!(
             "{}",
             p.belongs_to()
@@ -466,10 +462,10 @@ fn pretty(possible_pw: Option<Passwd>) {
         let login = cstr2cow!(getlogin() as *const _);
         let rid = getuid();
         if let Ok(p) = Passwd::locate(rid) {
-            if login == p.name() {
+            if login == p.name {
                 println!("login\t{}", login);
             }
-            println!("uid\t{}", p.name());
+            println!("uid\t{}", p.name);
         } else {
             println!("uid\t{}", rid);
         }
@@ -477,7 +473,7 @@ fn pretty(possible_pw: Option<Passwd>) {
         let eid = getegid();
         if eid == rid {
             if let Ok(p) = Passwd::locate(eid) {
-                println!("euid\t{}", p.name());
+                println!("euid\t{}", p.name);
             } else {
                 println!("euid\t{}", eid);
             }
@@ -486,7 +482,7 @@ fn pretty(possible_pw: Option<Passwd>) {
         let rid = getgid();
         if rid != eid {
             if let Ok(g) = Group::locate(rid) {
-                println!("euid\t{}", g.name());
+                println!("euid\t{}", g.name);
             } else {
                 println!("euid\t{}", rid);
             }
@@ -511,16 +507,16 @@ fn pline(possible_uid: Option<uid_t>) {
 
     println!(
         "{}:{}:{}:{}:{}:{}:{}:{}:{}:{}",
-        pw.name(),
-        pw.user_passwd(),
-        pw.uid(),
-        pw.gid(),
-        pw.user_access_class(),
-        pw.passwd_change_time(),
-        pw.expiration(),
-        pw.user_info(),
-        pw.user_dir(),
-        pw.user_shell()
+        pw.name,
+        pw.user_passwd,
+        pw.uid,
+        pw.gid,
+        pw.user_access_class,
+        pw.passwd_change_time,
+        pw.expiration,
+        pw.user_info,
+        pw.user_dir,
+        pw.user_shell
     );
 }
 
@@ -531,13 +527,7 @@ fn pline(possible_uid: Option<uid_t>) {
 
     println!(
         "{}:{}:{}:{}:{}:{}:{}",
-        pw.name(),
-        pw.user_passwd(),
-        pw.uid(),
-        pw.gid(),
-        pw.user_info(),
-        pw.user_dir(),
-        pw.user_shell()
+        pw.name, pw.user_passwd, pw.uid, pw.gid, pw.user_info, pw.user_dir, pw.user_shell
     );
 }
 
@@ -561,7 +551,7 @@ fn auditid() {
     println!("asid={}", auditinfo.ai_asid);
 }
 
-fn id_print(state: &mut State, groups: Vec<u32>) {
+fn id_print(state: &mut State, groups: &[u32]) {
     let uid = state.ids.as_ref().unwrap().uid;
     let gid = state.ids.as_ref().unwrap().gid;
     let euid = state.ids.as_ref().unwrap().euid;
diff --git a/src/uu/id/src/main.rs b/src/uu/id/src/main.rs
index c8f6fe6aa..21a7a8514 100644
--- a/src/uu/id/src/main.rs
+++ b/src/uu/id/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_id);
+uucore::bin!(uu_id);
diff --git a/src/uu/install/Cargo.toml b/src/uu/install/Cargo.toml
index 0ae11b3c4..f82c6de34 100644
--- a/src/uu/install/Cargo.toml
+++ b/src/uu/install/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "uu_install"
-version = "0.0.8"
+version = "0.0.13"
 authors = [
     "Ben Eills <ben@beneills.com>",
     "uutils developers",
@@ -9,7 +9,7 @@ license = "MIT"
 description = "install ~ (uutils) copy files from SOURCE to DESTINATION (with specified attributes)"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/install"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/install"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -18,15 +18,11 @@ edition = "2018"
 path = "src/install.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 filetime = "0.2"
 file_diff = "1.0.0"
 libc = ">= 0.2"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs", "mode", "perms", "entries"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-
-[dev-dependencies]
-time = "0.1.40"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs", "mode", "perms", "entries"] }
 
 [[bin]]
 name = "install"
diff --git a/src/uu/install/LICENSE b/src/uu/install/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/install/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/install/src/install.rs b/src/uu/install/src/install.rs
index a93add322..e3154aa51 100644
--- a/src/uu/install/src/install.rs
+++ b/src/uu/install/src/install.rs
@@ -12,13 +12,15 @@ mod mode;
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, 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};
+use uucore::error::{FromIo, UError, UIoError, UResult, UUsageError};
+use uucore::format_usage;
+use uucore::fs::dir_strip_dot_for_creation;
 use uucore::mode::get_umask;
 use uucore::perms::{wrap_chown, Verbosity, VerbosityLevel};
 
@@ -29,7 +31,7 @@ use std::fs;
 use std::fs::File;
 use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
-use std::process::Command;
+use std::process;
 
 const DEFAULT_MODE: u32 = 0o755;
 const DEFAULT_STRIP_PROGRAM: &str = "strip";
@@ -144,6 +146,7 @@ impl Behavior {
 
 static ABOUT: &str = "Copy SOURCE to DEST or multiple SOURCE(s) to the existing
  DIRECTORY, while setting permission modes and owner/group";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
 static OPT_COMPARE: &str = "compare";
 static OPT_DIRECTORY: &str = "directory";
@@ -163,19 +166,13 @@ static OPT_CONTEXT: &str = "context";
 
 static ARG_FILES: &str = "files";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
-
 /// Main install utility function, called from main.rs.
 ///
 /// Returns a program return code.
 ///
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     let paths: Vec<String> = matches
         .values_of(ARG_FILES)
@@ -187,15 +184,17 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let behavior = behavior(&matches)?;
 
     match behavior.main_function {
-        MainFunction::Directory => directory(paths, behavior),
-        MainFunction::Standard => standard(paths, behavior),
+        MainFunction::Directory => directory(&paths, &behavior),
+        MainFunction::Standard => standard(paths, &behavior),
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
             backup_control::arguments::backup()
         )
@@ -203,67 +202,67 @@ pub fn uu_app() -> App<'static, 'static> {
             backup_control::arguments::backup_no_args()
         )
         .arg(
-            Arg::with_name(OPT_IGNORED)
-            .short("c")
+            Arg::new(OPT_IGNORED)
+            .short('c')
             .help("ignored")
         )
         .arg(
-            Arg::with_name(OPT_COMPARE)
-            .short("C")
+            Arg::new(OPT_COMPARE)
+            .short('C')
             .long(OPT_COMPARE)
             .help("compare each pair of source and destination files, and in some cases, do not modify the destination at all")
         )
         .arg(
-            Arg::with_name(OPT_DIRECTORY)
-                .short("d")
+            Arg::new(OPT_DIRECTORY)
+                .short('d')
                 .long(OPT_DIRECTORY)
                 .help("treat all arguments as directory names. create all components of the specified directories")
         )
 
         .arg(
             // TODO implement flag
-            Arg::with_name(OPT_CREATE_LEADING)
-                .short("D")
+            Arg::new(OPT_CREATE_LEADING)
+                .short('D')
                 .help("create all leading components of DEST except the last, then copy SOURCE to DEST")
         )
         .arg(
-            Arg::with_name(OPT_GROUP)
-                .short("g")
+            Arg::new(OPT_GROUP)
+                .short('g')
                 .long(OPT_GROUP)
                 .help("set group ownership, instead of process's current group")
                 .value_name("GROUP")
                 .takes_value(true)
         )
         .arg(
-            Arg::with_name(OPT_MODE)
-                .short("m")
+            Arg::new(OPT_MODE)
+                .short('m')
                 .long(OPT_MODE)
                 .help("set permission mode (as in chmod), instead of rwxr-xr-x")
                 .value_name("MODE")
                 .takes_value(true)
         )
         .arg(
-            Arg::with_name(OPT_OWNER)
-                .short("o")
+            Arg::new(OPT_OWNER)
+                .short('o')
                 .long(OPT_OWNER)
                 .help("set ownership (super-user only)")
                 .value_name("OWNER")
                 .takes_value(true)
         )
         .arg(
-            Arg::with_name(OPT_PRESERVE_TIMESTAMPS)
-                .short("p")
+            Arg::new(OPT_PRESERVE_TIMESTAMPS)
+                .short('p')
                 .long(OPT_PRESERVE_TIMESTAMPS)
                 .help("apply access/modification times of SOURCE files to corresponding destination files")
         )
         .arg(
-            Arg::with_name(OPT_STRIP)
-                .short("s")
+            Arg::new(OPT_STRIP)
+                .short('s')
                 .long(OPT_STRIP)
                 .help("strip symbol tables (no action Windows)")
         )
         .arg(
-            Arg::with_name(OPT_STRIP_PROGRAM)
+            Arg::new(OPT_STRIP_PROGRAM)
                 .long(OPT_STRIP_PROGRAM)
                 .help("program used to strip binaries (no action Windows)")
                 .value_name("PROGRAM")
@@ -273,42 +272,42 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         .arg(
             // TODO implement flag
-            Arg::with_name(OPT_TARGET_DIRECTORY)
-                .short("t")
+            Arg::new(OPT_TARGET_DIRECTORY)
+                .short('t')
                 .long(OPT_TARGET_DIRECTORY)
                 .help("move all SOURCE arguments into DIRECTORY")
                 .value_name("DIRECTORY")
         )
         .arg(
             // TODO implement flag
-            Arg::with_name(OPT_NO_TARGET_DIRECTORY)
-                .short("T")
+            Arg::new(OPT_NO_TARGET_DIRECTORY)
+                .short('T')
                 .long(OPT_NO_TARGET_DIRECTORY)
                 .help("(unimplemented) treat DEST as a normal file")
 
         )
         .arg(
-            Arg::with_name(OPT_VERBOSE)
-            .short("v")
+            Arg::new(OPT_VERBOSE)
+            .short('v')
             .long(OPT_VERBOSE)
             .help("explain what is being done")
         )
         .arg(
             // TODO implement flag
-            Arg::with_name(OPT_PRESERVE_CONTEXT)
-                .short("P")
+            Arg::new(OPT_PRESERVE_CONTEXT)
+                .short('P')
                 .long(OPT_PRESERVE_CONTEXT)
                 .help("(unimplemented) preserve security context")
         )
         .arg(
             // TODO implement flag
-            Arg::with_name(OPT_CONTEXT)
-                .short("Z")
+            Arg::new(OPT_CONTEXT)
+                .short('Z')
                 .long(OPT_CONTEXT)
                 .help("(unimplemented) set security context of files and directories")
                 .value_name("CONTEXT")
         )
-        .arg(Arg::with_name(ARG_FILES).multiple(true).takes_value(true).min_values(1))
+        .arg(Arg::new(ARG_FILES).multiple_occurrences(true).takes_value(true).min_values(1))
 }
 
 /// Check for unimplemented command line arguments.
@@ -390,13 +389,18 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
 ///
 /// Returns a Result type with the Err variant containing the error message.
 ///
-fn directory(paths: Vec<String>, b: Behavior) -> UResult<()> {
+fn directory(paths: &[String], b: &Behavior) -> UResult<()> {
     if paths.is_empty() {
         Err(InstallError::DirNeedsArg().into())
     } else {
         for path in paths.iter().map(Path::new) {
             // if the path already exist, don't try to create it again
             if !path.exists() {
+                // Special case to match GNU's behavior:
+                // install -d foo/. should work and just create foo/
+                // std::fs::create_dir("foo/."); fails in pure Rust
+                // See also mkdir.rs for another occurrence of this
+                let path_to_create = dir_strip_dot_for_creation(path);
                 // Differently than the primary functionality
                 // (MainFunction::Standard), the directory functionality should
                 // create all ancestors (or components) of a directory
@@ -406,15 +410,15 @@ fn directory(paths: Vec<String>, b: Behavior) -> UResult<()> {
                 // target directory. All created ancestor directories will have
                 // the default mode. Hence it is safe to use fs::create_dir_all
                 // and then only modify the target's dir mode.
-                if let Err(e) =
-                    fs::create_dir_all(path).map_err_context(|| path.maybe_quote().to_string())
+                if let Err(e) = fs::create_dir_all(path_to_create.as_path())
+                    .map_err_context(|| path_to_create.as_path().maybe_quote().to_string())
                 {
                     show!(e);
                     continue;
                 }
 
                 if b.verbose {
-                    println!("creating directory {}", path.quote());
+                    println!("creating directory {}", path_to_create.quote());
                 }
             }
 
@@ -443,17 +447,20 @@ fn is_new_file_path(path: &Path) -> bool {
 ///
 /// Returns a Result type with the Err variant containing the error message.
 ///
-fn standard(mut paths: Vec<String>, b: Behavior) -> UResult<()> {
-    let target: PathBuf = b
-        .target_dir
-        .clone()
-        .unwrap_or_else(|| paths.pop().unwrap())
-        .into();
+fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
+    let target: PathBuf = if let Some(path) = &b.target_dir {
+        path.into()
+    } else {
+        paths
+            .pop()
+            .ok_or_else(|| UUsageError::new(1, "missing file operand"))?
+            .into()
+    };
 
     let sources = &paths.iter().map(PathBuf::from).collect::<Vec<_>>();
 
     if sources.len() > 1 || (target.exists() && target.is_dir()) {
-        copy_files_into_dir(sources, &target, &b)
+        copy_files_into_dir(sources, &target, b)
     } else {
         if let Some(parent) = target.parent() {
             if !parent.exists() && b.create_leading {
@@ -470,7 +477,19 @@ fn standard(mut paths: Vec<String>, b: Behavior) -> UResult<()> {
         }
 
         if target.is_file() || is_new_file_path(&target) {
-            copy(&sources[0], &target, &b)
+            copy(
+                sources.get(0).ok_or_else(|| {
+                    UUsageError::new(
+                        1,
+                        format!(
+                            "missing destination file operand after '{}'",
+                            target.to_str().unwrap()
+                        ),
+                    )
+                })?,
+                &target,
+                b,
+            )
         } else {
             Err(InstallError::InvalidTarget(target).into())
         }
@@ -572,7 +591,7 @@ fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
     }
 
     if b.strip && cfg!(not(windows)) {
-        match Command::new(&b.strip_program).arg(to).output() {
+        match process::Command::new(&b.strip_program).arg(to).output() {
             Ok(o) => {
                 if !o.status.success() {
                     return Err(InstallError::StripProgramFailed(
@@ -681,7 +700,7 @@ fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
 /// Return true if a file is necessary to copy. This is the case when:
 ///
 /// - _from_ or _to_ is nonexistent;
-/// - either file has a sticky bit or set[ug]id bit, or the user specified one;
+/// - either file has a sticky bit or set\[ug\]id bit, or the user specified one;
 /// - either file isn't a regular file;
 /// - the sizes of _from_ and _to_ differ;
 /// - _to_'s owner differs from intended; or
diff --git a/src/uu/install/src/main.rs b/src/uu/install/src/main.rs
index d296ec4a2..993acae6a 100644
--- a/src/uu/install/src/main.rs
+++ b/src/uu/install/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_install);
+uucore::bin!(uu_install);
diff --git a/src/uu/join/BENCHMARKING.md b/src/uu/join/BENCHMARKING.md
new file mode 100644
index 000000000..07a006b2d
--- /dev/null
+++ b/src/uu/join/BENCHMARKING.md
@@ -0,0 +1,55 @@
+# Benchmarking join
+
+<!-- spell-checker:ignore (words) CSVs nocheck hotpaths -->
+
+## Performance profile
+
+The amount of time spent in which part of the code can vary depending on the files being joined and the flags used.
+A benchmark with `-j` and `-i` shows the following time:
+
+| Function/Method  | Fraction of Samples | Why? |
+| ---------------- | ------------------- | ---- |
+| `Line::new`      | 27% | Linear search for field separators, plus some vector operations. |
+| `read_until`     | 22% | Mostly libc reading file contents, with a few vector operations to represent them. |
+| `Input::compare` | 20% | ~2/3 making the keys lowercase, ~1/3 comparing them. |
+| `print_fields`   | 11% | Writing to and flushing the buffer. |
+| Other            | 20% | |
+| libc             | 25% | I/O and memory allocation. |
+
+More detailed profiles can be obtained via [flame graphs](https://github.com/flamegraph-rs/flamegraph):
+```
+cargo flamegraph --bin join --package uu_join -- file1 file2 > /dev/null
+```
+You may need to add the following lines to the top-level `Cargo.toml` to get full stack traces:
+```
+[profile.release]
+debug = true
+```
+
+## How to benchmark
+
+Benchmarking typically requires files large enough to ensure that the benchmark is not overwhelmed by background system noise; say, on the order of tens of MB.
+While `join` operates on line-oriented data, and not properly formatted CSVs (e.g., `join` is not designed to accommodate escaped or quoted delimiters),
+in practice many CSV datasets will function well after being sorted.
+
+Like most of the utils, the recommended tool for benchmarking is [hyperfine](https://github.com/sharkdp/hyperfine).
+To benchmark your changes:
+ - checkout the main branch (without your changes), do a `--release` build, and back up the executable produced at `target/release/join`
+ - checkout your working branch (with your changes), do a `--release` build
+ - run
+   ```
+   hyperfine -w 5 "/path/to/main/branch/build/join file1 file2" "/path/to/working/branch/build/join file1 file2"
+   ```
+   - you'll likely need to add additional options to both commands, such as a field separator, or if you're benchmarking some particular behavior
+   - you can also optionally benchmark against GNU's join
+
+## What to benchmark
+
+The following options can have a non-trivial impact on performance:
+ - `-a`/`-v` if one of the two files has significantly more lines than the other
+ - `-j`/`-1`/`-2` cause work to be done to grab the appropriate field
+ - `-i` adds a call to `to_ascii_lowercase()` that adds some time for allocating and dropping memory for the lowercase key
+ - `--nocheck-order` causes some calls of `Input::compare` to be skipped
+
+The content of the files being joined has a very significant impact on the performance.
+Things like how long each line is, how many fields there are, how long the key fields are, how many lines there are, how many lines can be joined, and how many lines each line can be joined with all change the behavior of the hotpaths.
diff --git a/src/uu/join/Cargo.toml b/src/uu/join/Cargo.toml
index 1c140f544..c4d8cb57c 100644
--- a/src/uu/join/Cargo.toml
+++ b/src/uu/join/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_join"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "join ~ (uutils) merge lines from inputs with matching join fields"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/join"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/join"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,10 @@ edition = "2018"
 path = "src/join.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
+memchr = "2"
 
 [[bin]]
 name = "join"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/join/LICENSE b/src/uu/join/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/join/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/join/src/join.rs b/src/uu/join/src/join.rs
index 51dfeec6f..ef19fe328 100644
--- a/src/uu/join/src/join.rs
+++ b/src/uu/join/src/join.rs
@@ -10,23 +10,67 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
+use memchr::{memchr3_iter, memchr_iter};
 use std::cmp::Ordering;
+use std::convert::From;
+use std::error::Error;
+use std::fmt::Display;
 use std::fs::File;
-use std::io::{stdin, BufRead, BufReader, Lines, Stdin};
+use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Split, Stdin, Write};
+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};
 
 static NAME: &str = "join";
 
+#[derive(Debug)]
+enum JoinError {
+    IOError(std::io::Error),
+    UnorderedInput(String),
+}
+
+impl UError for JoinError {
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+impl Error for JoinError {}
+
+impl Display for JoinError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            JoinError::IOError(e) => write!(f, "io error: {}", e),
+            JoinError::UnorderedInput(e) => f.write_str(e),
+        }
+    }
+}
+
+impl From<std::io::Error> for JoinError {
+    fn from(error: std::io::Error) -> Self {
+        Self::IOError(error)
+    }
+}
+
 #[derive(Copy, Clone, PartialEq)]
 enum FileNum {
     File1,
     File2,
 }
 
+#[repr(u8)]
 #[derive(Copy, Clone)]
+enum LineEnding {
+    Nul = 0,
+    Newline = b'\n',
+}
+
+#[derive(Copy, Clone, PartialEq)]
 enum Sep {
-    Char(char),
+    Char(u8),
     Line,
     Whitespaces,
 }
@@ -45,27 +89,29 @@ struct Settings {
     print_unpaired2: bool,
     print_joined: bool,
     ignore_case: bool,
+    line_ending: LineEnding,
     separator: Sep,
     autoformat: bool,
     format: Vec<Spec>,
-    empty: String,
+    empty: Vec<u8>,
     check_order: CheckOrder,
     headers: bool,
 }
 
 impl Default for Settings {
-    fn default() -> Settings {
-        Settings {
+    fn default() -> Self {
+        Self {
             key1: 0,
             key2: 0,
             print_unpaired1: false,
             print_unpaired2: false,
             print_joined: true,
             ignore_case: false,
+            line_ending: LineEnding::Newline,
             separator: Sep::Whitespaces,
             autoformat: false,
             format: vec![],
-            empty: String::new(),
+            empty: vec![],
             check_order: CheckOrder::Default,
             headers: false,
         }
@@ -74,14 +120,21 @@ impl Default for Settings {
 
 /// Output representation.
 struct Repr<'a> {
-    separator: char,
+    line_ending: LineEnding,
+    separator: u8,
     format: &'a [Spec],
-    empty: &'a str,
+    empty: &'a [u8],
 }
 
 impl<'a> Repr<'a> {
-    fn new(separator: char, format: &'a [Spec], empty: &'a str) -> Repr<'a> {
+    fn new(
+        line_ending: LineEnding,
+        separator: u8,
+        format: &'a [Spec],
+        empty: &'a [u8],
+    ) -> Repr<'a> {
         Repr {
+            line_ending,
             separator,
             format,
             empty,
@@ -93,32 +146,43 @@ impl<'a> Repr<'a> {
     }
 
     /// Print the field or empty filler if the field is not set.
-    fn print_field(&self, field: Option<&str>) {
+    fn print_field(
+        &self,
+        writer: &mut impl Write,
+        field: Option<&[u8]>,
+    ) -> Result<(), std::io::Error> {
         let value = match field {
             Some(field) => field,
             None => self.empty,
         };
 
-        print!("{}", value);
+        writer.write_all(value)
     }
 
     /// Print each field except the one at the index.
-    fn print_fields(&self, line: &Line, index: usize) {
-        for i in 0..line.fields.len() {
+    fn print_fields(
+        &self,
+        writer: &mut impl Write,
+        line: &Line,
+        index: usize,
+    ) -> Result<(), std::io::Error> {
+        for i in 0..line.field_ranges.len() {
             if i != index {
-                print!("{}{}", self.separator, line.fields[i]);
+                writer.write_all(&[self.separator])?;
+                writer.write_all(line.get_field(i).unwrap())?;
             }
         }
+        Ok(())
     }
 
     /// Print each field or the empty filler if the field is not set.
-    fn print_format<F>(&self, f: F)
+    fn print_format<F>(&self, writer: &mut impl Write, f: F) -> Result<(), std::io::Error>
     where
-        F: Fn(&Spec) -> Option<&'a str>,
+        F: Fn(&Spec) -> Option<&'a [u8]>,
     {
         for i in 0..self.format.len() {
             if i > 0 {
-                print!("{}", self.separator);
+                writer.write_all(&[self.separator])?;
             }
 
             let field = match f(&self.format[i]) {
@@ -126,8 +190,13 @@ impl<'a> Repr<'a> {
                 None => self.empty,
             };
 
-            print!("{}", field);
+            writer.write_all(field)?;
         }
+        Ok(())
+    }
+
+    fn print_line_ending(&self, writer: &mut impl Write) -> Result<(), std::io::Error> {
+        writer.write_all(&[self.line_ending as u8])
     }
 }
 
@@ -139,18 +208,20 @@ struct Input {
 }
 
 impl Input {
-    fn new(separator: Sep, ignore_case: bool, check_order: CheckOrder) -> Input {
-        Input {
+    fn new(separator: Sep, ignore_case: bool, check_order: CheckOrder) -> Self {
+        Self {
             separator,
             ignore_case,
             check_order,
         }
     }
 
-    fn compare(&self, field1: Option<&str>, field2: Option<&str>) -> Ordering {
+    fn compare(&self, field1: Option<&[u8]>, field2: Option<&[u8]>) -> Ordering {
         if let (Some(field1), Some(field2)) = (field1, field2) {
             if self.ignore_case {
-                field1.to_lowercase().cmp(&field2.to_lowercase())
+                field1
+                    .to_ascii_lowercase()
+                    .cmp(&field2.to_ascii_lowercase())
             } else {
                 field1.cmp(field2)
             }
@@ -172,50 +243,77 @@ enum Spec {
 }
 
 impl Spec {
-    fn parse(format: &str) -> Spec {
+    fn parse(format: &str) -> UResult<Self> {
         let mut chars = format.chars();
 
         let file_num = match chars.next() {
             Some('0') => {
                 // Must be all alone without a field specifier.
                 if chars.next().is_none() {
-                    return Spec::Key;
+                    return Ok(Self::Key);
                 }
-
-                crash!(1, "invalid field specifier: {}", format.quote());
+                return Err(USimpleError::new(
+                    1,
+                    format!("invalid field specifier: {}", format.quote()),
+                ));
             }
             Some('1') => FileNum::File1,
             Some('2') => FileNum::File2,
-            _ => crash!(1, "invalid file number in field spec: {}", format.quote()),
+            _ => {
+                return Err(USimpleError::new(
+                    1,
+                    format!("invalid file number in field spec: {}", format.quote()),
+                ));
+            }
         };
 
         if let Some('.') = chars.next() {
-            return Spec::Field(file_num, parse_field_number(chars.as_str()));
+            return Ok(Self::Field(file_num, parse_field_number(chars.as_str())?));
         }
 
-        crash!(1, "invalid field specifier: {}", format.quote());
+        Err(USimpleError::new(
+            1,
+            format!("invalid field specifier: {}", format.quote()),
+        ))
     }
 }
 
 struct Line {
-    fields: Vec<String>,
+    field_ranges: Vec<(usize, usize)>,
+    string: Vec<u8>,
 }
 
 impl Line {
-    fn new(string: String, separator: Sep) -> Line {
-        let fields = match separator {
-            Sep::Whitespaces => string.split_whitespace().map(String::from).collect(),
-            Sep::Char(sep) => string.split(sep).map(String::from).collect(),
-            Sep::Line => vec![string],
-        };
+    fn new(string: Vec<u8>, separator: Sep, len_guess: usize) -> Self {
+        let mut field_ranges = Vec::with_capacity(len_guess);
+        let mut last_end = 0;
+        if separator == Sep::Whitespaces {
+            // GNU join uses Bourne shell field splitters by default
+            for i in memchr3_iter(b' ', b'\t', b'\n', &string) {
+                if i > last_end {
+                    field_ranges.push((last_end, i));
+                }
+                last_end = i + 1;
+            }
+        } else if let Sep::Char(sep) = separator {
+            for i in memchr_iter(sep, &string) {
+                field_ranges.push((last_end, i));
+                last_end = i + 1;
+            }
+        }
+        field_ranges.push((last_end, string.len()));
 
-        Line { fields }
+        Self {
+            field_ranges,
+            string,
+        }
     }
 
     /// Get field at index.
-    fn get_field(&self, index: usize) -> Option<&str> {
-        if index < self.fields.len() {
-            Some(&self.fields[index])
+    fn get_field(&self, index: usize) -> Option<&[u8]> {
+        if index < self.field_ranges.len() {
+            let (low, high) = self.field_ranges[index];
+            Some(&self.string[low..high])
         } else {
             None
         }
@@ -227,10 +325,12 @@ struct State<'a> {
     file_name: &'a str,
     file_num: FileNum,
     print_unpaired: bool,
-    lines: Lines<Box<dyn BufRead + 'a>>,
+    lines: Split<Box<dyn BufRead + 'a>>,
+    max_len: usize,
     seq: Vec<Line>,
     line_num: usize,
     has_failed: bool,
+    has_unpaired: bool,
 }
 
 impl<'a> State<'a> {
@@ -239,6 +339,7 @@ impl<'a> State<'a> {
         name: &'a str,
         stdin: &'a Stdin,
         key: usize,
+        line_ending: LineEnding,
         print_unpaired: bool,
     ) -> State<'a> {
         let f = if name == "-" {
@@ -255,59 +356,79 @@ impl<'a> State<'a> {
             file_name: name,
             file_num,
             print_unpaired,
-            lines: f.lines(),
+            lines: f.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, input: &Input, repr: &Repr) {
+    fn skip_line(
+        &mut self,
+        writer: &mut impl Write,
+        input: &Input,
+        repr: &Repr,
+    ) -> Result<(), JoinError> {
         if self.print_unpaired {
-            self.print_first_line(repr);
+            self.print_first_line(writer, repr)?;
         }
 
-        self.reset_next_line(input);
+        self.reset_next_line(input)?;
+        Ok(())
     }
 
     /// Keep reading line sequence until the key does not change, return
     /// the first line whose key differs.
-    fn extend(&mut self, input: &Input) -> Option<Line> {
-        while let Some(line) = self.next_line(input) {
+    fn extend(&mut self, input: &Input) -> Result<Option<Line>, JoinError> {
+        while let Some(line) = self.next_line(input)? {
             let diff = input.compare(self.get_current_key(), line.get_field(self.key));
 
             if diff == Ordering::Equal {
                 self.seq.push(line);
             } else {
-                return Some(line);
+                return Ok(Some(line));
             }
         }
 
-        None
+        Ok(None)
     }
 
     /// Print lines in the buffers as headers.
-    fn print_headers(&self, other: &State, repr: &Repr) {
+    fn print_headers(
+        &self,
+        writer: &mut impl Write,
+        other: &State,
+        repr: &Repr,
+    ) -> Result<(), std::io::Error> {
         if self.has_line() {
             if other.has_line() {
-                self.combine(other, repr);
+                self.combine(writer, other, repr)?;
             } else {
-                self.print_first_line(repr);
+                self.print_first_line(writer, repr)?;
             }
         } else if other.has_line() {
-            other.print_first_line(repr);
+            other.print_first_line(writer, repr)?;
         }
+
+        Ok(())
     }
 
     /// Combine two line sequences.
-    fn combine(&self, other: &State, repr: &Repr) {
+    fn combine(
+        &self,
+        writer: &mut impl Write,
+        other: &State,
+        repr: &Repr,
+    ) -> Result<(), std::io::Error> {
         let key = self.get_current_key();
 
         for line1 in &self.seq {
             for line2 in &other.seq {
                 if repr.uses_format() {
-                    repr.print_format(|spec| match *spec {
+                    repr.print_format(writer, |spec| match *spec {
                         Spec::Key => key,
                         Spec::Field(file_num, field_num) => {
                             if file_num == self.file_num {
@@ -320,16 +441,18 @@ impl<'a> State<'a> {
 
                             None
                         }
-                    });
+                    })?;
                 } else {
-                    repr.print_field(key);
-                    repr.print_fields(line1, self.key);
-                    repr.print_fields(line2, other.key);
+                    repr.print_field(writer, key)?;
+                    repr.print_fields(writer, line1, self.key)?;
+                    repr.print_fields(writer, line2, other.key)?;
                 }
 
-                println!();
+                repr.print_line_ending(writer)?;
             }
         }
+
+        Ok(())
     }
 
     /// Reset with the next line.
@@ -341,14 +464,16 @@ impl<'a> State<'a> {
         }
     }
 
-    fn reset_read_line(&mut self, input: &Input) {
-        let line = self.read_line(input.separator);
+    fn reset_read_line(&mut self, input: &Input) -> Result<(), std::io::Error> {
+        let line = self.read_line(input.separator)?;
         self.reset(line);
+        Ok(())
     }
 
-    fn reset_next_line(&mut self, input: &Input) {
-        let line = self.next_line(input);
+    fn reset_next_line(&mut self, input: &Input) -> Result<(), JoinError> {
+        let line = self.next_line(input)?;
         self.reset(line);
+        Ok(())
     }
 
     fn has_line(&self) -> bool {
@@ -356,69 +481,101 @@ impl<'a> State<'a> {
     }
 
     fn initialize(&mut self, read_sep: Sep, autoformat: bool) -> usize {
-        if let Some(line) = self.read_line(read_sep) {
+        if let Some(line) = crash_if_err!(1, self.read_line(read_sep)) {
             self.seq.push(line);
 
             if autoformat {
-                return self.seq[0].fields.len();
+                return self.seq[0].field_ranges.len();
             }
         }
         0
     }
 
-    fn finalize(&mut self, input: &Input, repr: &Repr) {
-        if self.has_line() && self.print_unpaired {
-            self.print_first_line(repr);
+    fn finalize(
+        &mut self,
+        writer: &mut impl Write,
+        input: &Input,
+        repr: &Repr,
+    ) -> Result<(), JoinError> {
+        if self.has_line() {
+            if self.print_unpaired {
+                self.print_first_line(writer, repr)?;
+            }
 
-            while let Some(line) = self.next_line(input) {
-                self.print_line(&line, repr);
+            let mut next_line = self.next_line(input)?;
+            while let Some(line) = &next_line {
+                if self.print_unpaired {
+                    self.print_line(writer, line, repr)?;
+                }
+                self.reset(next_line);
+                next_line = self.next_line(input)?;
             }
         }
+
+        Ok(())
     }
 
     /// Get the next line without the order check.
-    fn read_line(&mut self, sep: Sep) -> Option<Line> {
-        let value = self.lines.next()?;
-        self.line_num += 1;
-        Some(Line::new(crash_if_err!(1, value), sep))
+    fn read_line(&mut self, sep: Sep) -> Result<Option<Line>, std::io::Error> {
+        match self.lines.next() {
+            Some(value) => {
+                self.line_num += 1;
+                let line = Line::new(value?, sep, self.max_len);
+                if line.field_ranges.len() > self.max_len {
+                    self.max_len = line.field_ranges.len();
+                }
+                Ok(Some(line))
+            }
+            None => Ok(None),
+        }
     }
 
     /// Get the next line with the order check.
-    fn next_line(&mut self, input: &Input) -> Option<Line> {
-        let line = self.read_line(input.separator)?;
-
-        if input.check_order == CheckOrder::Disabled {
-            return Some(line);
-        }
-
-        let diff = input.compare(self.get_current_key(), line.get_field(self.key));
-
-        if diff == Ordering::Greater {
-            eprintln!(
-                "{}:{}: is not sorted",
-                self.file_name.maybe_quote(),
-                self.line_num
-            );
-
-            // This is fatal if the check is enabled.
-            if input.check_order == CheckOrder::Enabled {
-                exit!(1);
+    fn next_line(&mut self, input: &Input) -> Result<Option<Line>, JoinError> {
+        if let Some(line) = self.read_line(input.separator)? {
+            if input.check_order == CheckOrder::Disabled {
+                return Ok(Some(line));
             }
 
-            self.has_failed = true;
-        }
+            let diff = input.compare(self.get_current_key(), line.get_field(self.key));
 
-        Some(line)
+            if diff == Ordering::Greater
+                && (input.check_order == CheckOrder::Enabled
+                    || (self.has_unpaired && !self.has_failed))
+            {
+                let err_msg = format!(
+                    "{}:{}: is not sorted: {}",
+                    self.file_name.maybe_quote(),
+                    self.line_num,
+                    String::from_utf8_lossy(&line.string)
+                );
+                // This is fatal if the check is enabled.
+                if input.check_order == CheckOrder::Enabled {
+                    return Err(JoinError::UnorderedInput(err_msg));
+                }
+                eprintln!("{}: {}", uucore::execution_phrase(), err_msg);
+                self.has_failed = true;
+            }
+
+            Ok(Some(line))
+        } else {
+            Ok(None)
+        }
     }
 
     /// Gets the key value of the lines stored in seq.
-    fn get_current_key(&self) -> Option<&str> {
+    fn get_current_key(&self) -> Option<&[u8]> {
         self.seq[0].get_field(self.key)
     }
 
-    fn print_line(&self, line: &Line, repr: &Repr) {
+    fn print_line(
+        &self,
+        writer: &mut impl Write,
+        line: &Line,
+        repr: &Repr,
+    ) -> Result<(), std::io::Error> {
         if repr.uses_format() {
-            repr.print_format(|spec| match *spec {
+            repr.print_format(writer, |spec| match *spec {
                 Spec::Key => line.get_field(self.key),
                 Spec::Field(file_num, field_num) => {
                     if file_num == self.file_num {
@@ -427,26 +584,27 @@ impl<'a> State<'a> {
                         None
                     }
                 }
-            });
+            })?;
         } else {
-            repr.print_field(line.get_field(self.key));
-            repr.print_fields(line, self.key);
+            repr.print_field(writer, line.get_field(self.key))?;
+            repr.print_fields(writer, line, self.key)?;
         }
 
-        println!();
+        repr.print_line_ending(writer)
     }
 
-    fn print_first_line(&self, repr: &Repr) {
-        self.print_line(&self.seq[0], repr);
+    fn print_first_line(&self, writer: &mut impl Write, repr: &Repr) -> Result<(), std::io::Error> {
+        self.print_line(writer, &self.seq[0], repr)
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().get_matches_from(args);
 
-    let keys = parse_field_number_option(matches.value_of("j"));
-    let key1 = parse_field_number_option(matches.value_of("1"));
-    let key2 = parse_field_number_option(matches.value_of("2"));
+    let keys = parse_field_number_option(matches.value_of("j"))?;
+    let key1 = parse_field_number_option(matches.value_of("1"))?;
+    let key2 = parse_field_number_option(matches.value_of("2"))?;
 
     let mut settings: Settings = Default::default();
 
@@ -459,21 +617,39 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         .unwrap_or_default()
         .chain(matches.values_of("a").unwrap_or_default());
     for file_num in unpaired {
-        match parse_file_number(file_num) {
+        match parse_file_number(file_num)? {
             FileNum::File1 => settings.print_unpaired1 = true,
             FileNum::File2 => settings.print_unpaired2 = true,
         }
     }
 
     settings.ignore_case = matches.is_present("i");
-    settings.key1 = get_field_number(keys, key1);
-    settings.key2 = get_field_number(keys, key2);
+    settings.key1 = get_field_number(keys, key1)?;
+    settings.key2 = get_field_number(keys, key2)?;
 
-    if let Some(value) = matches.value_of("t") {
+    if let Some(value_os) = matches.value_of_os("t") {
+        #[cfg(unix)]
+        let value = value_os.as_bytes();
+        #[cfg(not(unix))]
+        let value = match value_os.to_str() {
+            Some(value) => value.as_bytes(),
+            None => {
+                return Err(USimpleError::new(
+                    1,
+                    "unprintable field separators are only supported on unix-like platforms",
+                ))
+            }
+        };
         settings.separator = match value.len() {
             0 => Sep::Line,
-            1 => Sep::Char(value.chars().next().unwrap()),
-            _ => crash!(1, "multi-character tab {}", value),
+            1 => Sep::Char(value[0]),
+            2 if value[0] == b'\\' && value[1] == b'0' => Sep::Char(0),
+            _ => {
+                return Err(USimpleError::new(
+                    1,
+                    format!("multi-character tab {}", value_os.to_string_lossy()),
+                ))
+            }
         };
     }
 
@@ -481,15 +657,16 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         if format == "auto" {
             settings.autoformat = true;
         } else {
-            settings.format = format
-                .split(|c| c == ' ' || c == ',' || c == '\t')
-                .map(Spec::parse)
-                .collect();
+            let mut specs = vec![];
+            for part in format.split(|c| c == ' ' || c == ',' || c == '\t') {
+                specs.push(Spec::parse(part)?);
+            }
+            settings.format = specs;
         }
     }
 
     if let Some(empty) = matches.value_of("e") {
-        settings.empty = empty.to_string();
+        settings.empty = empty.as_bytes().to_vec();
     }
 
     if matches.is_present("nocheck-order") {
@@ -504,18 +681,25 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         settings.headers = true;
     }
 
+    if matches.is_present("z") {
+        settings.line_ending = LineEnding::Nul;
+    }
+
     let file1 = matches.value_of("file1").unwrap();
     let file2 = matches.value_of("file2").unwrap();
 
     if file1 == "-" && file2 == "-" {
-        crash!(1, "both files cannot be standard input");
+        return Err(USimpleError::new(1, "both files cannot be standard input"));
     }
 
-    exec(file1, file2, settings)
+    match exec(file1, file2, settings) {
+        Ok(_) => Ok(()),
+        Err(e) => Err(USimpleError::new(1, format!("{}", e))),
+    }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(NAME)
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(NAME)
         .version(crate_version!())
         .about(
             "For each pair of input lines with identical join fields, write a line to
@@ -523,12 +707,11 @@ standard output. The default join field is the first, delimited by blanks.
 
 When FILE1 or FILE2 (not both) is -, read standard input.",
         )
-        .help_message("display this help and exit")
-        .version_message("display version and exit")
+        .infer_long_args(true)
         .arg(
-            Arg::with_name("a")
-                .short("a")
-                .multiple(true)
+            Arg::new("a")
+                .short('a')
+                .multiple_occurrences(true)
                 .number_of_values(1)
                 .possible_values(&["1", "2"])
                 .value_name("FILENUM")
@@ -538,90 +721,97 @@ FILENUM is 1 or 2, corresponding to FILE1 or FILE2",
                 ),
         )
         .arg(
-            Arg::with_name("v")
-                .short("v")
-                .multiple(true)
+            Arg::new("v")
+                .short('v')
+                .multiple_occurrences(true)
                 .number_of_values(1)
                 .possible_values(&["1", "2"])
                 .value_name("FILENUM")
                 .help("like -a FILENUM, but suppress joined output lines"),
         )
         .arg(
-            Arg::with_name("e")
-                .short("e")
+            Arg::new("e")
+                .short('e')
                 .takes_value(true)
                 .value_name("EMPTY")
                 .help("replace missing input fields with EMPTY"),
         )
         .arg(
-            Arg::with_name("i")
-                .short("i")
+            Arg::new("i")
+                .short('i')
                 .long("ignore-case")
                 .help("ignore differences in case when comparing fields"),
         )
         .arg(
-            Arg::with_name("j")
-                .short("j")
+            Arg::new("j")
+                .short('j')
                 .takes_value(true)
                 .value_name("FIELD")
                 .help("equivalent to '-1 FIELD -2 FIELD'"),
         )
         .arg(
-            Arg::with_name("o")
-                .short("o")
+            Arg::new("o")
+                .short('o')
                 .takes_value(true)
                 .value_name("FORMAT")
                 .help("obey FORMAT while constructing output line"),
         )
         .arg(
-            Arg::with_name("t")
-                .short("t")
+            Arg::new("t")
+                .short('t')
                 .takes_value(true)
                 .value_name("CHAR")
+                .allow_invalid_utf8(true)
                 .help("use CHAR as input and output field separator"),
         )
         .arg(
-            Arg::with_name("1")
-                .short("1")
+            Arg::new("1")
+                .short('1')
                 .takes_value(true)
                 .value_name("FIELD")
                 .help("join on this FIELD of file 1"),
         )
         .arg(
-            Arg::with_name("2")
-                .short("2")
+            Arg::new("2")
+                .short('2')
                 .takes_value(true)
                 .value_name("FIELD")
                 .help("join on this FIELD of file 2"),
         )
-        .arg(Arg::with_name("check-order").long("check-order").help(
+        .arg(Arg::new("check-order").long("check-order").help(
             "check that the input is correctly sorted, \
              even if all input lines are pairable",
         ))
         .arg(
-            Arg::with_name("nocheck-order")
+            Arg::new("nocheck-order")
                 .long("nocheck-order")
                 .help("do not check that the input is correctly sorted"),
         )
-        .arg(Arg::with_name("header").long("header").help(
+        .arg(Arg::new("header").long("header").help(
             "treat the first line in each file as field headers, \
              print them without trying to pair them",
         ))
         .arg(
-            Arg::with_name("file1")
-                .required(true)
-                .value_name("FILE1")
-                .hidden(true),
+            Arg::new("z")
+                .short('z')
+                .long("zero-terminated")
+                .help("line delimiter is NUL, not newline"),
         )
         .arg(
-            Arg::with_name("file2")
+            Arg::new("file1")
+                .required(true)
+                .value_name("FILE1")
+                .hide(true),
+        )
+        .arg(
+            Arg::new("file2")
                 .required(true)
                 .value_name("FILE2")
-                .hidden(true),
+                .hide(true),
         )
 }
 
-fn exec(file1: &str, file2: &str, settings: Settings) -> i32 {
+fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
     let stdin = stdin();
 
     let mut state1 = State::new(
@@ -629,6 +819,7 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> i32 {
         file1,
         &stdin,
         settings.key1,
+        settings.line_ending,
         settings.print_unpaired1,
     );
 
@@ -637,6 +828,7 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> i32 {
         file2,
         &stdin,
         settings.key2,
+        settings.line_ending,
         settings.print_unpaired2,
     );
 
@@ -666,18 +858,22 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> i32 {
     };
 
     let repr = Repr::new(
+        settings.line_ending,
         match settings.separator {
             Sep::Char(sep) => sep,
-            _ => ' ',
+            _ => b' ',
         },
         &format,
         &settings.empty,
     );
 
+    let stdout = stdout();
+    let mut writer = BufWriter::new(stdout.lock());
+
     if settings.headers {
-        state1.print_headers(&state2, &repr);
-        state1.reset_read_line(&input);
-        state2.reset_read_line(&input);
+        state1.print_headers(&mut writer, &state2, &repr)?;
+        state1.reset_read_line(&input)?;
+        state2.reset_read_line(&input)?;
     }
 
     while state1.has_line() && state2.has_line() {
@@ -685,17 +881,39 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> i32 {
 
         match diff {
             Ordering::Less => {
-                state1.skip_line(&input, &repr);
+                if let Err(e) = state1.skip_line(&mut writer, &input, &repr) {
+                    writer.flush()?;
+                    return Err(e);
+                }
+                state1.has_unpaired = true;
+                state2.has_unpaired = true;
             }
             Ordering::Greater => {
-                state2.skip_line(&input, &repr);
+                if let Err(e) = state2.skip_line(&mut writer, &input, &repr) {
+                    writer.flush()?;
+                    return Err(e);
+                }
+                state1.has_unpaired = true;
+                state2.has_unpaired = true;
             }
             Ordering::Equal => {
-                let next_line1 = state1.extend(&input);
-                let next_line2 = state2.extend(&input);
+                let next_line1 = match state1.extend(&input) {
+                    Ok(line) => line,
+                    Err(e) => {
+                        writer.flush()?;
+                        return Err(e);
+                    }
+                };
+                let next_line2 = match state2.extend(&input) {
+                    Ok(line) => line,
+                    Err(e) => {
+                        writer.flush()?;
+                        return Err(e);
+                    }
+                };
 
                 if settings.print_joined {
-                    state1.combine(&state2, &repr);
+                    state1.combine(&mut writer, &state2, &repr)?;
                 }
 
                 state1.reset(next_line1);
@@ -704,46 +922,74 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> i32 {
         }
     }
 
-    state1.finalize(&input, &repr);
-    state2.finalize(&input, &repr);
+    if let Err(e) = state1.finalize(&mut writer, &input, &repr) {
+        writer.flush()?;
+        return Err(e);
+    };
+    if let Err(e) = state2.finalize(&mut writer, &input, &repr) {
+        writer.flush()?;
+        return Err(e);
+    };
 
-    (state1.has_failed || state2.has_failed) as i32
+    writer.flush()?;
+
+    if state1.has_failed || state2.has_failed {
+        eprintln!(
+            "{}: input is not in sorted order",
+            uucore::execution_phrase()
+        );
+        set_exit_code(1);
+    }
+    Ok(())
 }
 
 /// Check that keys for both files and for a particular file are not
 /// contradictory and return the key index.
-fn get_field_number(keys: Option<usize>, key: Option<usize>) -> usize {
+fn get_field_number(keys: Option<usize>, key: Option<usize>) -> UResult<usize> {
     if let Some(keys) = keys {
         if let Some(key) = key {
             if keys != key {
                 // Show zero-based field numbers as one-based.
-                crash!(1, "incompatible join fields {}, {}", keys + 1, key + 1);
+                return Err(USimpleError::new(
+                    1,
+                    format!("incompatible join fields {}, {}", keys + 1, key + 1),
+                ));
             }
         }
 
-        return keys;
+        return Ok(keys);
     }
 
-    key.unwrap_or(0)
+    Ok(key.unwrap_or(0))
 }
 
 /// Parse the specified field string as a natural number and return
 /// the zero-based field number.
-fn parse_field_number(value: &str) -> usize {
+fn parse_field_number(value: &str) -> UResult<usize> {
     match value.parse::<usize>() {
-        Ok(result) if result > 0 => result - 1,
-        _ => crash!(1, "invalid field number: {}", value.quote()),
+        Ok(result) if result > 0 => Ok(result - 1),
+        Err(e) if e.kind() == &IntErrorKind::PosOverflow => Ok(usize::MAX),
+        _ => Err(USimpleError::new(
+            1,
+            format!("invalid field number: {}", value.quote()),
+        )),
     }
 }
 
-fn parse_file_number(value: &str) -> FileNum {
+fn parse_file_number(value: &str) -> UResult<FileNum> {
     match value {
-        "1" => FileNum::File1,
-        "2" => FileNum::File2,
-        value => crash!(1, "invalid file number: {}", value.quote()),
+        "1" => Ok(FileNum::File1),
+        "2" => Ok(FileNum::File2),
+        value => Err(USimpleError::new(
+            1,
+            format!("invalid file number: {}", value.quote()),
+        )),
     }
 }
 
-fn parse_field_number_option(value: Option<&str>) -> Option<usize> {
-    Some(parse_field_number(value?))
+fn parse_field_number_option(value: Option<&str>) -> UResult<Option<usize>> {
+    match value {
+        None => Ok(None),
+        Some(val) => Ok(Some(parse_field_number(val)?)),
+    }
 }
diff --git a/src/uu/join/src/main.rs b/src/uu/join/src/main.rs
index 5114252cd..7520de6d7 100644
--- a/src/uu/join/src/main.rs
+++ b/src/uu/join/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_join);
+uucore::bin!(uu_join);
diff --git a/src/uu/kill/Cargo.toml b/src/uu/kill/Cargo.toml
index 452b0f407..9eea3172b 100644
--- a/src/uu/kill/Cargo.toml
+++ b/src/uu/kill/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_kill"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "kill ~ (uutils) send a signal to a process"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/kill"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/kill"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/kill.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["signals"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["signals"] }
 
 [[bin]]
 name = "kill"
diff --git a/src/uu/kill/LICENSE b/src/uu/kill/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/kill/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/kill/src/kill.rs b/src/uu/kill/src/kill.rs
index e9b7ee349..df868e418 100644
--- a/src/uu/kill/src/kill.rs
+++ b/src/uu/kill/src/kill.rs
@@ -10,15 +10,16 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use libc::{c_int, pid_t};
 use std::io::Error;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
 use uucore::signals::{signal_by_name_or_value, ALL_SIGNALS};
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "Send signal to processes or list information about signals.";
+const USAGE: &str = "{} [OPTIONS]... PID...";
 
 pub mod options {
     pub static PIDS_OR_SIGNALS: &str = "pids_of_signals";
@@ -35,15 +36,14 @@ pub enum Mode {
     List,
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let mut args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
     let obs_signal = handle_obsolete(&mut args);
 
-    let usage = format!("{} [OPTIONS]... PID...", uucore::execution_phrase());
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     let mode = if matches.is_present(options::TABLE) || matches.is_present(options::TABLE_OLD) {
         Mode::Table
@@ -74,40 +74,42 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             table();
             Ok(())
         }
-        Mode::List => list(pids_or_signals.get(0).cloned()),
+        Mode::List => list(pids_or_signals.get(0)),
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::LIST)
-                .short("l")
+            Arg::new(options::LIST)
+                .short('l')
                 .long(options::LIST)
                 .help("Lists signals")
                 .conflicts_with(options::TABLE)
                 .conflicts_with(options::TABLE_OLD),
         )
         .arg(
-            Arg::with_name(options::TABLE)
-                .short("t")
+            Arg::new(options::TABLE)
+                .short('t')
                 .long(options::TABLE)
                 .help("Lists table of signals"),
         )
-        .arg(Arg::with_name(options::TABLE_OLD).short("L").hidden(true))
+        .arg(Arg::new(options::TABLE_OLD).short('L').hide(true))
         .arg(
-            Arg::with_name(options::SIGNAL)
-                .short("s")
+            Arg::new(options::SIGNAL)
+                .short('s')
                 .long(options::SIGNAL)
                 .help("Sends given signal")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::PIDS_OR_SIGNALS)
-                .hidden(true)
-                .multiple(true),
+            Arg::new(options::PIDS_OR_SIGNALS)
+                .hide(true)
+                .multiple_occurrences(true),
         )
 }
 
@@ -167,9 +169,9 @@ fn print_signals() {
     println!();
 }
 
-fn list(arg: Option<String>) -> UResult<()> {
+fn list(arg: Option<&String>) -> UResult<()> {
     match arg {
-        Some(ref x) => print_signal(x),
+        Some(x) => print_signal(x),
         None => {
             print_signals();
             Ok(())
diff --git a/src/uu/kill/src/main.rs b/src/uu/kill/src/main.rs
index 91d0a28f0..6f3fbac47 100644
--- a/src/uu/kill/src/main.rs
+++ b/src/uu/kill/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_kill);
+uucore::bin!(uu_kill);
diff --git a/src/uu/link/Cargo.toml b/src/uu/link/Cargo.toml
index 275d3b5cc..caec3e2a6 100644
--- a/src/uu/link/Cargo.toml
+++ b/src/uu/link/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_link"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "link ~ (uutils) create a hard (file system) link to FILE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/link"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/link"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,9 @@ edition = "2018"
 path = "src/link.rs"
 
 [dependencies]
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "link"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/link/LICENSE b/src/uu/link/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/link/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/link/src/link.rs b/src/uu/link/src/link.rs
index 73e81b107..3c959af33 100644
--- a/src/uu/link/src/link.rs
+++ b/src/uu/link/src/link.rs
@@ -4,35 +4,23 @@
 //  *
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
-
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::hard_link;
-use std::io::Error;
 use std::path::Path;
+use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
+use uucore::format_usage;
 
 static ABOUT: &str = "Call the link function to create a link named FILE2 to an existing FILE1.";
+const USAGE: &str = "{} FILE1 FILE2";
 
 pub mod options {
     pub static FILES: &str = "FILES";
 }
 
-fn usage() -> String {
-    format!("{0} FILE1 FILE2", uucore::execution_phrase())
-}
-
-pub fn normalize_error_message(e: Error) -> String {
-    match e.raw_os_error() {
-        Some(2) => String::from("No such file or directory (os error 2)"),
-        _ => format!("{}", e),
-    }
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let files: Vec<_> = matches
         .values_of_os(options::FILES)
@@ -41,25 +29,23 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     let old = Path::new(files[0]);
     let new = Path::new(files[1]);
 
-    match hard_link(old, new) {
-        Ok(_) => 0,
-        Err(err) => {
-            show_error!("{}", normalize_error_message(err));
-            1
-        }
-    }
+    hard_link(old, new)
+        .map_err_context(|| format!("cannot create link {} to {}", new.quote(), old.quote()))
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::FILES)
-                .hidden(true)
+            Arg::new(options::FILES)
+                .hide(true)
                 .required(true)
                 .min_values(2)
                 .max_values(2)
-                .takes_value(true),
+                .takes_value(true)
+                .allow_invalid_utf8(true),
         )
 }
diff --git a/src/uu/link/src/main.rs b/src/uu/link/src/main.rs
index ccc565fed..8c4e653f4 100644
--- a/src/uu/link/src/main.rs
+++ b/src/uu/link/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_link);
+uucore::bin!(uu_link);
diff --git a/src/uu/ln/Cargo.toml b/src/uu/ln/Cargo.toml
index ba2c8de96..9fd6b3d12 100644
--- a/src/uu/ln/Cargo.toml
+++ b/src/uu/ln/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_ln"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ln ~ (uutils) create a (file system) link to TARGET"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/ln"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ln"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,8 @@ edition = "2018"
 path = "src/ln.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "ln"
diff --git a/src/uu/ln/LICENSE b/src/uu/ln/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/ln/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/ln/src/ln.rs b/src/uu/ln/src/ln.rs
index e480d8f13..088edf219 100644
--- a/src/uu/ln/src/ln.rs
+++ b/src/uu/ln/src/ln.rs
@@ -10,9 +10,10 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use uucore::display::Quotable;
 use uucore::error::{UError, UResult};
+use uucore::format_usage;
 
 use std::borrow::Cow;
 use std::error::Error;
@@ -52,7 +53,8 @@ pub enum OverwriteMode {
 enum LnError {
     TargetIsDirectory(PathBuf),
     SomeLinksFailed,
-    FailedToLink(String),
+    FailedToLink(PathBuf, PathBuf, String),
+    SameFile(),
     MissingDestination(PathBuf),
     ExtraOperand(OsString),
 }
@@ -61,7 +63,12 @@ impl Display for LnError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::TargetIsDirectory(s) => write!(f, "target {} is not a directory", s.quote()),
-            Self::FailedToLink(e) => write!(f, "failed to link: {}", e),
+            Self::FailedToLink(s, d, e) => {
+                write!(f, "failed to link {} to {}: {}", s.quote(), d.quote(), e)
+            }
+            Self::SameFile() => {
+                write!(f, "Same file")
+            }
             Self::SomeLinksFailed => write!(f, "some links failed to create"),
             Self::MissingDestination(s) => {
                 write!(f, "missing destination file operand after {}", s.quote())
@@ -81,25 +88,16 @@ impl Error for LnError {}
 impl UError for LnError {
     fn code(&self) -> i32 {
         match self {
-            Self::TargetIsDirectory(_) => 1,
-            Self::SomeLinksFailed => 1,
-            Self::FailedToLink(_) => 1,
-            Self::MissingDestination(_) => 1,
-            Self::ExtraOperand(_) => 1,
+            Self::TargetIsDirectory(_)
+            | Self::SomeLinksFailed
+            | Self::FailedToLink(_, _, _)
+            | Self::SameFile()
+            | Self::MissingDestination(_)
+            | Self::ExtraOperand(_) => 1,
         }
     }
 }
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [-T] TARGET LINK_NAME   (1st form)
-       {0} [OPTION]... TARGET                  (2nd form)
-       {0} [OPTION]... TARGET... DIRECTORY     (3rd form)
-       {0} [OPTION]... -t DIRECTORY TARGET...  (4th form)",
-        uucore::execution_phrase()
-    )
-}
-
 fn long_usage() -> String {
     String::from(
         " In the 1st form, create a link to TARGET with the name LINK_NAME.
@@ -115,6 +113,11 @@ fn long_usage() -> String {
 }
 
 static ABOUT: &str = "change file owner and group";
+const USAGE: &str = "\
+    {} [OPTION]... [-T] TARGET LINK_NAME
+    {} [OPTION]... TARGET
+    {} [OPTION]... TARGET... DIRECTORY
+    {} [OPTION]... -t DIRECTORY TARGET...";
 
 mod options {
     pub const FORCE: &str = "force";
@@ -129,13 +132,11 @@ mod options {
 
 static ARG_FILES: &str = "files";
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
     let long_usage = long_usage();
 
     let matches = uu_app()
-        .usage(&usage[..])
         .after_help(&*format!(
             "{}\n{}",
             long_usage,
@@ -179,30 +180,32 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     exec(&paths[..], &settings)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(backup_control::arguments::backup())
         .arg(backup_control::arguments::backup_no_args())
         // TODO: opts.arg(
-        //    Arg::with_name(("d", "directory", "allow users with appropriate privileges to attempt \
+        //    Arg::new(("d", "directory", "allow users with appropriate privileges to attempt \
         //                                       to make hard links to directories");
         .arg(
-            Arg::with_name(options::FORCE)
-                .short("f")
+            Arg::new(options::FORCE)
+                .short('f')
                 .long(options::FORCE)
                 .help("remove existing destination files"),
         )
         .arg(
-            Arg::with_name(options::INTERACTIVE)
-                .short("i")
+            Arg::new(options::INTERACTIVE)
+                .short('i')
                 .long(options::INTERACTIVE)
                 .help("prompt whether to remove existing destination files"),
         )
         .arg(
-            Arg::with_name(options::NO_DEREFERENCE)
-                .short("n")
+            Arg::new(options::NO_DEREFERENCE)
+                .short('n')
                 .long(options::NO_DEREFERENCE)
                 .help(
                     "treat LINK_NAME as a normal file if it is a \
@@ -210,13 +213,13 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         // TODO: opts.arg(
-        //    Arg::with_name(("L", "logical", "dereference TARGETs that are symbolic links");
+        //    Arg::new(("L", "logical", "dereference TARGETs that are symbolic links");
         //
         // TODO: opts.arg(
-        //    Arg::with_name(("P", "physical", "make hard links directly to symbolic links");
+        //    Arg::new(("P", "physical", "make hard links directly to symbolic links");
         .arg(
-            Arg::with_name(options::SYMBOLIC)
-                .short("s")
+            Arg::new(options::SYMBOLIC)
+                .short('s')
                 .long("symbolic")
                 .help("make symbolic links instead of hard links")
                 // override added for https://github.com/uutils/coreutils/issues/2359
@@ -224,35 +227,35 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         .arg(backup_control::arguments::suffix())
         .arg(
-            Arg::with_name(options::TARGET_DIRECTORY)
-                .short("t")
+            Arg::new(options::TARGET_DIRECTORY)
+                .short('t')
                 .long(options::TARGET_DIRECTORY)
                 .help("specify the DIRECTORY in which to create the links")
                 .value_name("DIRECTORY")
                 .conflicts_with(options::NO_TARGET_DIRECTORY),
         )
         .arg(
-            Arg::with_name(options::NO_TARGET_DIRECTORY)
-                .short("T")
+            Arg::new(options::NO_TARGET_DIRECTORY)
+                .short('T')
                 .long(options::NO_TARGET_DIRECTORY)
                 .help("treat LINK_NAME as a normal file always"),
         )
         .arg(
-            Arg::with_name(options::RELATIVE)
-                .short("r")
+            Arg::new(options::RELATIVE)
+                .short('r')
                 .long(options::RELATIVE)
                 .help("create symbolic links relative to link location")
                 .requires(options::SYMBOLIC),
         )
         .arg(
-            Arg::with_name(options::VERBOSE)
-                .short("v")
+            Arg::new(options::VERBOSE)
+                .short('v')
                 .long(options::VERBOSE)
                 .help("print name of each linked file"),
         )
         .arg(
-            Arg::with_name(ARG_FILES)
-                .multiple(true)
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .required(true)
                 .min_values(1),
@@ -289,7 +292,12 @@ fn exec(files: &[PathBuf], settings: &Settings) -> UResult<()> {
 
     match link(&files[0], &files[1], settings) {
         Ok(_) => Ok(()),
-        Err(e) => Err(LnError::FailedToLink(e.to_string()).into()),
+        Err(e) => {
+            Err(
+                LnError::FailedToLink(files[0].to_owned(), files[1].to_owned(), e.to_string())
+                    .into(),
+            )
+        }
     }
 }
 
@@ -307,7 +315,7 @@ fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings)
                 if is_symlink(target_dir) {
                     if target_dir.is_file() {
                         if let Err(e) = fs::remove_file(target_dir) {
-                            show_error!("Could not update {}: {}", target_dir.quote(), e)
+                            show_error!("Could not update {}: {}", target_dir.quote(), e);
                         };
                     }
                     if target_dir.is_dir() {
@@ -315,7 +323,7 @@ fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings)
                         // considered as a dir
                         // See test_ln::test_symlink_no_deref_dir
                         if let Err(e) = fs::remove_dir(target_dir) {
-                            show_error!("Could not update {}: {}", target_dir.quote(), e)
+                            show_error!("Could not update {}: {}", target_dir.quote(), e);
                         };
                     }
                 }
@@ -385,7 +393,7 @@ fn relative_path<'a>(src: &Path, dst: &Path) -> Result<Cow<'a, Path>> {
     Ok(result.into())
 }
 
-fn link(src: &Path, dst: &Path, settings: &Settings) -> Result<()> {
+fn link(src: &Path, dst: &Path, settings: &Settings) -> UResult<()> {
     let mut backup_path = None;
     let source: Cow<'_, Path> = if settings.relative {
         relative_path(src, dst)?
@@ -394,6 +402,27 @@ fn link(src: &Path, dst: &Path, settings: &Settings) -> Result<()> {
     };
 
     if is_symlink(dst) || dst.exists() {
+        backup_path = match settings.backup {
+            BackupMode::NoBackup => None,
+            BackupMode::SimpleBackup => Some(simple_backup_path(dst, &settings.suffix)),
+            BackupMode::NumberedBackup => Some(numbered_backup_path(dst)),
+            BackupMode::ExistingBackup => Some(existing_backup_path(dst, &settings.suffix)),
+        };
+        if settings.backup == BackupMode::ExistingBackup && !settings.symbolic {
+            // when ln --backup f f, it should detect that it is the same file
+            let dst_abs = canonicalize(dst, MissingHandling::Normal, ResolveMode::Logical)?;
+            let source_abs = canonicalize(
+                source.clone(),
+                MissingHandling::Normal,
+                ResolveMode::Logical,
+            )?;
+            if dst_abs == source_abs {
+                return Err(LnError::SameFile().into());
+            }
+        }
+        if let Some(ref p) = backup_path {
+            fs::rename(dst, p)?;
+        }
         match settings.overwrite {
             OverwriteMode::NoClobber => {}
             OverwriteMode::Interactive => {
@@ -401,20 +430,15 @@ fn link(src: &Path, dst: &Path, settings: &Settings) -> Result<()> {
                 if !read_yes() {
                     return Ok(());
                 }
-                fs::remove_file(dst)?
-            }
-            OverwriteMode::Force => fs::remove_file(dst)?,
-        };
 
-        backup_path = match settings.backup {
-            BackupMode::NoBackup => None,
-            BackupMode::SimpleBackup => Some(simple_backup_path(dst, &settings.suffix)),
-            BackupMode::NumberedBackup => Some(numbered_backup_path(dst)),
-            BackupMode::ExistingBackup => Some(existing_backup_path(dst, &settings.suffix)),
+                if fs::remove_file(dst).is_ok() {};
+                // In case of error, don't do anything
+            }
+            OverwriteMode::Force => {
+                if fs::remove_file(dst).is_ok() {};
+                // In case of error, don't do anything
+            }
         };
-        if let Some(ref p) = backup_path {
-            fs::rename(dst, p)?;
-        }
     }
 
     if settings.symbolic {
@@ -462,7 +486,7 @@ fn numbered_backup_path(path: &Path) -> PathBuf {
 }
 
 fn existing_backup_path(path: &Path, suffix: &str) -> PathBuf {
-    let test_path = simple_backup_path(path, &".~1~".to_owned());
+    let test_path = simple_backup_path(path, ".~1~");
     if test_path.exists() {
         return numbered_backup_path(path);
     }
diff --git a/src/uu/ln/src/main.rs b/src/uu/ln/src/main.rs
index 060001972..c59835fc3 100644
--- a/src/uu/ln/src/main.rs
+++ b/src/uu/ln/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_ln);
+uucore::bin!(uu_ln);
diff --git a/src/uu/logname/Cargo.toml b/src/uu/logname/Cargo.toml
index ed19ff887..d800d41b0 100644
--- a/src/uu/logname/Cargo.toml
+++ b/src/uu/logname/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_logname"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "logname ~ (uutils) display the login name of the current user"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/logname"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/logname"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/logname.rs"
 
 [dependencies]
-libc = "0.2.42"
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+libc = "0.2.121"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "logname"
diff --git a/src/uu/logname/LICENSE b/src/uu/logname/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/logname/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/logname/src/logname.rs b/src/uu/logname/src/logname.rs
index 56866ff62..31246b5c7 100644
--- a/src/uu/logname/src/logname.rs
+++ b/src/uu/logname/src/logname.rs
@@ -12,11 +12,11 @@
 #[macro_use]
 extern crate uucore;
 
+use clap::{crate_version, Command};
 use std::ffi::CStr;
+use uucore::error::UResult;
 use uucore::InvalidEncodingHandling;
 
-use clap::{crate_version, App};
-
 extern "C" {
     // POSIX requires using getlogin (or equivalent code)
     pub fn getlogin() -> *const libc::c_char;
@@ -35,27 +35,26 @@ fn get_userlogin() -> Option<String> {
 
 static SUMMARY: &str = "Print user's login name";
 
-fn usage() -> &'static str {
-    uucore::execution_phrase()
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
-    let _ = uu_app().usage(usage()).get_matches_from(args);
+    let _ = uu_app().get_matches_from(args);
 
     match get_userlogin() {
         Some(userlogin) => println!("{}", userlogin),
         None => show_error!("no login name"),
     }
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
+        .override_usage(uucore::execution_phrase())
         .about(SUMMARY)
+        .infer_long_args(true)
 }
diff --git a/src/uu/logname/src/main.rs b/src/uu/logname/src/main.rs
index f9cf6160e..ef5d7d46d 100644
--- a/src/uu/logname/src/main.rs
+++ b/src/uu/logname/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_logname);
+uucore::bin!(uu_logname);
diff --git a/src/uu/ls/Cargo.toml b/src/uu/ls/Cargo.toml
index b918f6501..d082c8260 100644
--- a/src/uu/ls/Cargo.toml
+++ b/src/uu/ls/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_ls"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ls ~ (uutils) display directory contents"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/ls"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ls"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -16,18 +16,17 @@ path = "src/ls.rs"
 
 [dependencies]
 chrono = "0.4.19"
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo", "env"] }
 unicode-width = "0.1.8"
 number_prefix = "0.4"
 term_grid = "0.1.5"
 termsize = "0.1.6"
-globset = "0.4.6"
+glob = "0.3.0"
 lscolors = { version = "0.7.1", features = ["ansi_term"] }
 uucore = { version = ">=0.0.8", package = "uucore", path = "../../uucore", features = ["entries", "fs"] }
-uucore_procs = { version=">=0.0.7", package = "uucore_procs", path = "../../uucore_procs" }
-once_cell = "1.7.2"
+once_cell = "1.10.0"
 atty = "0.2"
-selinux = { version="0.2.1", optional = true }
+selinux = { version="0.2", optional = true }
 
 [target.'cfg(unix)'.dependencies]
 lazy_static = "1.4.0"
@@ -38,7 +37,3 @@ path = "src/main.rs"
 
 [features]
 feat_selinux = ["selinux"]
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/ls/LICENSE b/src/uu/ls/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/ls/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/ls/src/ls.rs b/src/uu/ls/src/ls.rs
index 3fa3b4f8e..778283039 100644
--- a/src/uu/ls/src/ls.rs
+++ b/src/uu/ls/src/ls.rs
@@ -15,21 +15,21 @@ extern crate lazy_static;
 
 mod quoting_style;
 
-use clap::{crate_version, App, Arg};
-use globset::{self, Glob, GlobSet, GlobSetBuilder};
+use clap::{crate_version, Arg, Command};
+use glob::Pattern;
 use lscolors::LsColors;
 use number_prefix::NumberPrefix;
 use once_cell::unsync::OnceCell;
 use quoting_style::{escape_name, QuotingStyle};
-use std::ffi::OsString;
 #[cfg(windows)]
 use std::os::windows::fs::MetadataExt;
 use std::{
     cmp::Reverse,
     error::Error,
+    ffi::{OsStr, OsString},
     fmt::Display,
-    fs::{self, DirEntry, FileType, Metadata},
-    io::{stdout, BufWriter, Stdout, Write},
+    fs::{self, DirEntry, FileType, Metadata, ReadDir},
+    io::{stdout, BufWriter, ErrorKind, Stdout, Write},
     path::{Path, PathBuf},
     time::{SystemTime, UNIX_EPOCH},
 };
@@ -40,24 +40,24 @@ use std::{
     time::Duration,
 };
 use term_grid::{Cell, Direction, Filling, Grid, GridOptions};
-use uucore::{
-    display::Quotable,
-    error::{set_exit_code, UError, UResult},
-};
-
 use unicode_width::UnicodeWidthStr;
 #[cfg(unix)]
 use uucore::libc::{S_IXGRP, S_IXOTH, S_IXUSR};
-use uucore::{fs::display_permissions, version_cmp::version_cmp};
+use uucore::{
+    display::Quotable,
+    error::{set_exit_code, UError, UResult},
+    format_usage,
+    fs::display_permissions,
+    parse_size::parse_size,
+    version_cmp::version_cmp,
+};
 
 #[cfg(not(feature = "selinux"))]
 static CONTEXT_HELP_TEXT: &str = "print any security context of each file (not enabled)";
 #[cfg(feature = "selinux")]
 static CONTEXT_HELP_TEXT: &str = "print any security context of each file";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
 pub mod options {
 
@@ -91,8 +91,11 @@ pub mod options {
     }
 
     pub mod size {
+        pub static ALLOCATION_SIZE: &str = "size";
+        pub static BLOCK_SIZE: &str = "block-size";
         pub static HUMAN_READABLE: &str = "human-readable";
         pub static SI: &str = "si";
+        pub static KIBIBYTES: &str = "kibibytes";
     }
 
     pub mod quoting {
@@ -113,6 +116,7 @@ pub mod options {
         pub static DIR_ARGS: &str = "dereference-command-line-symlink-to-dir";
     }
 
+    pub static HELP: &str = "help";
     pub static QUOTING_STYLE: &str = "quoting-style";
     pub static HIDE_CONTROL_CHARS: &str = "hide-control-chars";
     pub static SHOW_CONTROL_CHARS: &str = "show-control-chars";
@@ -138,18 +142,25 @@ pub mod options {
 }
 
 const DEFAULT_TERM_WIDTH: u16 = 80;
+const POSIXLY_CORRECT_BLOCK_SIZE: u64 = 512;
+#[cfg(unix)]
+const DEFAULT_BLOCK_SIZE: u64 = 1024;
 
 #[derive(Debug)]
 enum LsError {
     InvalidLineWidth(String),
-    NoMetadata(PathBuf),
+    IOError(std::io::Error),
+    IOErrorContext(std::io::Error, PathBuf),
+    BlockSizeParseError(String),
 }
 
 impl UError for LsError {
     fn code(&self) -> i32 {
         match self {
             LsError::InvalidLineWidth(_) => 2,
-            LsError::NoMetadata(_) => 1,
+            LsError::IOError(_) => 1,
+            LsError::IOErrorContext(_, _) => 1,
+            LsError::BlockSizeParseError(_) => 1,
         }
     }
 }
@@ -159,8 +170,73 @@ impl Error for LsError {}
 impl Display for LsError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            LsError::BlockSizeParseError(s) => {
+                write!(f, "invalid --block-size argument {}", s.quote())
+            }
             LsError::InvalidLineWidth(s) => write!(f, "invalid line width: {}", s.quote()),
-            LsError::NoMetadata(p) => write!(f, "could not open file: {}", p.quote()),
+            LsError::IOError(e) => write!(f, "general io error: {}", e),
+            LsError::IOErrorContext(e, p) => {
+                let error_kind = e.kind();
+                let errno = e.raw_os_error().unwrap_or(1i32);
+
+                match error_kind {
+                    // No such file or directory
+                    ErrorKind::NotFound => {
+                        write!(
+                            f,
+                            "cannot access '{}': No such file or directory",
+                            p.to_string_lossy(),
+                        )
+                    }
+                    // Permission denied and Operation not permitted
+                    ErrorKind::PermissionDenied =>
+                    {
+                        #[allow(clippy::wildcard_in_or_patterns)]
+                        match errno {
+                            1i32 => {
+                                write!(
+                                    f,
+                                    "cannot access '{}': Operation not permitted",
+                                    p.to_string_lossy(),
+                                )
+                            }
+                            13i32 | _ => {
+                                if p.is_dir() {
+                                    write!(
+                                        f,
+                                        "cannot open directory '{}': Permission denied",
+                                        p.to_string_lossy(),
+                                    )
+                                } else {
+                                    write!(
+                                        f,
+                                        "cannot open file '{}': Permission denied",
+                                        p.to_string_lossy(),
+                                    )
+                                }
+                            }
+                        }
+                    }
+                    _ => match errno {
+                        9i32 => {
+                            // only should ever occur on a read_dir on a bad fd
+                            write!(
+                                f,
+                                "cannot open directory '{}': Bad file descriptor",
+                                p.to_string_lossy(),
+                            )
+                        }
+                        _ => {
+                            write!(
+                                f,
+                                "unknown io error: '{:?}', '{:?}'",
+                                p.to_string_lossy(),
+                                e
+                            )
+                        }
+                    },
+                }
+            }
         }
     }
 }
@@ -174,6 +250,7 @@ enum Format {
     Commas,
 }
 
+#[derive(PartialEq, Eq)]
 enum Sort {
     None,
     Name,
@@ -183,6 +260,7 @@ enum Sort {
     Extension,
 }
 
+#[derive(PartialEq)]
 enum SizeFormat {
     Bytes,
     Binary,  // Powers of 1024, --human-readable, -h
@@ -233,7 +311,7 @@ struct Config {
     recursive: bool,
     reverse: bool,
     dereference: Dereference,
-    ignore_patterns: GlobSet,
+    ignore_patterns: Vec<Pattern>,
     size_format: SizeFormat,
     directory: bool,
     time: Time,
@@ -241,6 +319,8 @@ struct Config {
     inode: bool,
     color: Option<LsColors>,
     long: LongFormat,
+    alloc_size: bool,
+    block_size: Option<u64>,
     width: u16,
     quoting_style: QuotingStyle,
     indicator_style: IndicatorStyle,
@@ -259,16 +339,23 @@ struct LongFormat {
 }
 
 struct PaddingCollection {
-    longest_link_count_len: usize,
-    longest_uname_len: usize,
-    longest_group_len: usize,
-    longest_context_len: usize,
-    longest_size_len: usize,
+    #[cfg(unix)]
+    inode: usize,
+    link_count: usize,
+    uname: usize,
+    group: usize,
+    context: usize,
+    size: usize,
+    #[cfg(unix)]
+    major: usize,
+    #[cfg(unix)]
+    minor: usize,
+    block_size: usize,
 }
 
 impl Config {
     #[allow(clippy::cognitive_complexity)]
-    fn from(options: &clap::ArgMatches) -> UResult<Config> {
+    fn from(options: &clap::ArgMatches) -> UResult<Self> {
         let context = options.is_present(options::CONTEXT);
         let (mut format, opt) = if let Some(format_) = options.value_of(options::FORMAT) {
             (
@@ -399,14 +486,67 @@ impl Config {
             None
         };
 
-        let size_format = if options.is_present(options::size::HUMAN_READABLE) {
-            SizeFormat::Binary
-        } else if options.is_present(options::size::SI) {
+        let cmd_line_bs = options.value_of(options::size::BLOCK_SIZE);
+        let opt_si = cmd_line_bs.is_some()
+            && options
+                .value_of(options::size::BLOCK_SIZE)
+                .unwrap()
+                .eq("si")
+            || options.is_present(options::size::SI);
+        let opt_hr = (cmd_line_bs.is_some()
+            && options
+                .value_of(options::size::BLOCK_SIZE)
+                .unwrap()
+                .eq("human-readable"))
+            || options.is_present(options::size::HUMAN_READABLE);
+        let opt_kb = options.is_present(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 {
+            SizeFormat::Binary
         } else {
             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("")
+            }
+        } else {
+            OsString::from("")
+        };
+
+        let block_size: Option<u64> = if !opt_si && !opt_hr && !raw_bs.is_empty() {
+            match parse_size(&raw_bs.to_string_lossy()) {
+                Ok(size) => Some(size),
+                Err(_) => {
+                    show!(LsError::BlockSizeParseError(
+                        cmd_line_bs.unwrap().to_owned()
+                    ));
+                    None
+                }
+            }
+        } 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 {
+                None
+            }
+        } else {
+            None
+        };
+
         let long = {
             let author = options.is_present(options::AUTHOR);
             let group = !options.is_present(options::NO_GROUP)
@@ -455,8 +595,12 @@ impl Config {
             !atty::is(atty::Stream::Stdout)
         };
 
-        let quoting_style = if let Some(style) = options.value_of(options::QUOTING_STYLE) {
-            match style {
+        let opt_quoting_style = options
+            .value_of(options::QUOTING_STYLE)
+            .map(|cmd_line_qs| cmd_line_qs.to_owned());
+
+        let quoting_style = if let Some(style) = opt_quoting_style {
+            match style.as_str() {
                 "literal" => QuotingStyle::Literal { show_control },
                 "shell" => QuotingStyle::Shell {
                     escape: false,
@@ -513,8 +657,19 @@ impl Config {
                 "slash" => IndicatorStyle::Slash,
                 &_ => IndicatorStyle::None,
             }
-        } else if options.is_present(options::indicator_style::CLASSIFY) {
-            IndicatorStyle::Classify
+        } else if let Some(field) = options.value_of(options::indicator_style::CLASSIFY) {
+            match field {
+                "never" | "no" | "none" => IndicatorStyle::None,
+                "always" | "yes" | "force" => IndicatorStyle::Classify,
+                "auto" | "tty" | "if-tty" => {
+                    if atty::is(atty::Stream::Stdout) {
+                        IndicatorStyle::Classify
+                    } else {
+                        IndicatorStyle::None
+                    }
+                }
+                &_ => IndicatorStyle::None,
+            }
         } else if options.is_present(options::indicator_style::SLASH) {
             IndicatorStyle::Slash
         } else if options.is_present(options::indicator_style::FILE_TYPE) {
@@ -547,16 +702,18 @@ impl Config {
         } else {
             TimeStyle::Locale
         };
-        let mut ignore_patterns = GlobSetBuilder::new();
+
+        let mut ignore_patterns: Vec<Pattern> = Vec::new();
+
         if options.is_present(options::IGNORE_BACKUPS) {
-            ignore_patterns.add(Glob::new("*~").unwrap());
-            ignore_patterns.add(Glob::new(".*~").unwrap());
+            ignore_patterns.push(Pattern::new("*~").unwrap());
+            ignore_patterns.push(Pattern::new(".*~").unwrap());
         }
 
         for pattern in options.values_of(options::IGNORE).into_iter().flatten() {
-            match Glob::new(pattern) {
+            match Pattern::new(pattern) {
                 Ok(p) => {
-                    ignore_patterns.add(p);
+                    ignore_patterns.push(p);
                 }
                 Err(_) => show_warning!("Invalid pattern for ignore: {}", pattern.quote()),
             }
@@ -564,21 +721,15 @@ impl Config {
 
         if files == Files::Normal {
             for pattern in options.values_of(options::HIDE).into_iter().flatten() {
-                match Glob::new(pattern) {
+                match Pattern::new(pattern) {
                     Ok(p) => {
-                        ignore_patterns.add(p);
+                        ignore_patterns.push(p);
                     }
                     Err(_) => show_warning!("Invalid pattern for hide: {}", pattern.quote()),
                 }
             }
         }
 
-        if files == Files::Normal {
-            ignore_patterns.add(Glob::new(".*").unwrap());
-        }
-
-        let ignore_patterns = ignore_patterns.build().unwrap();
-
         let dereference = if options.is_present(options::dereference::ALL) {
             Dereference::All
         } else if options.is_present(options::dereference::ARGS) {
@@ -594,7 +745,7 @@ impl Config {
             Dereference::DirArgs
         };
 
-        Ok(Config {
+        Ok(Self {
             format,
             files,
             sort,
@@ -609,6 +760,8 @@ impl Config {
             #[cfg(unix)]
             inode: options.is_present(options::INODE),
             long,
+            alloc_size: options.is_present(options::size::ALLOCATION_SIZE),
+            block_size,
             width,
             quoting_style,
             indicator_style,
@@ -628,34 +781,40 @@ impl Config {
     }
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
+    let command = uu_app();
 
-    let app = uu_app().usage(&usage[..]);
-
-    let matches = app.get_matches_from(args);
+    let matches = command.get_matches_from(args);
 
     let config = Config::from(&matches)?;
+
     let locs = matches
         .values_of_os(options::PATHS)
         .map(|v| v.map(Path::new).collect())
         .unwrap_or_else(|| vec![Path::new(".")]);
 
-    list(locs, config)
+    list(locs, &config)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
+        .override_usage(format_usage(USAGE))
         .about(
             "By default, ls will list the files and contents of any directories on \
             the command line, expect that it will ignore files and directories \
             whose names start with '.'.",
         )
+        .infer_long_args(true)
+        .arg(
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information.")
+        )
         // Format arguments
         .arg(
-            Arg::with_name(options::FORMAT)
+            Arg::new(options::FORMAT)
                 .long(options::FORMAT)
                 .help("Set the display format.")
                 .takes_value(true)
@@ -680,8 +839,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::format::COLUMNS)
-                .short(options::format::COLUMNS)
+            Arg::new(options::format::COLUMNS)
+                .short('C')
                 .help("Display the files in columns.")
                 .overrides_with_all(&[
                     options::FORMAT,
@@ -692,8 +851,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::format::LONG)
-                .short("l")
+            Arg::new(options::format::LONG)
+                .short('l')
                 .long(options::format::LONG)
                 .help("Display detailed information.")
                 .overrides_with_all(&[
@@ -705,8 +864,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::format::ACROSS)
-                .short(options::format::ACROSS)
+            Arg::new(options::format::ACROSS)
+                .short('x')
                 .help("List entries in rows instead of in columns.")
                 .overrides_with_all(&[
                     options::FORMAT,
@@ -717,8 +876,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::format::COMMAS)
-                .short(options::format::COMMAS)
+            Arg::new(options::format::COMMAS)
+                .short('m')
                 .help("List entries separated by commas.")
                 .overrides_with_all(&[
                     options::FORMAT,
@@ -735,36 +894,36 @@ pub fn uu_app() -> App<'static, 'static> {
         // ls -1g1
         // even though `ls -11` and `ls -1 -g -1` work.
         .arg(
-            Arg::with_name(options::format::ONE_LINE)
-                .short(options::format::ONE_LINE)
+            Arg::new(options::format::ONE_LINE)
+                .short('1')
                 .help("List one file per line.")
-                .multiple(true),
+                .multiple_occurrences(true),
         )
         .arg(
-            Arg::with_name(options::format::LONG_NO_GROUP)
-                .short(options::format::LONG_NO_GROUP)
+            Arg::new(options::format::LONG_NO_GROUP)
+                .short('o')
                 .help(
                     "Long format without group information. \
                     Identical to --format=long with --no-group.",
                 )
-                .multiple(true),
+                .multiple_occurrences(true),
         )
         .arg(
-            Arg::with_name(options::format::LONG_NO_OWNER)
-                .short(options::format::LONG_NO_OWNER)
+            Arg::new(options::format::LONG_NO_OWNER)
+                .short('g')
                 .help("Long format without owner information.")
-                .multiple(true),
+                .multiple_occurrences(true),
         )
         .arg(
-            Arg::with_name(options::format::LONG_NUMERIC_UID_GID)
-                .short("n")
+            Arg::new(options::format::LONG_NUMERIC_UID_GID)
+                .short('n')
                 .long(options::format::LONG_NUMERIC_UID_GID)
                 .help("-l with numeric UIDs and GIDs.")
-                .multiple(true),
+                .multiple_occurrences(true),
         )
         // Quoting style
         .arg(
-            Arg::with_name(options::QUOTING_STYLE)
+            Arg::new(options::QUOTING_STYLE)
                 .long(options::QUOTING_STYLE)
                 .takes_value(true)
                 .help("Set quoting style.")
@@ -785,8 +944,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::quoting::LITERAL)
-                .short("N")
+            Arg::new(options::quoting::LITERAL)
+                .short('N')
                 .long(options::quoting::LITERAL)
                 .help("Use literal quoting style. Equivalent to `--quoting-style=literal`")
                 .overrides_with_all(&[
@@ -797,8 +956,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::quoting::ESCAPE)
-                .short("b")
+            Arg::new(options::quoting::ESCAPE)
+                .short('b')
                 .long(options::quoting::ESCAPE)
                 .help("Use escape quoting style. Equivalent to `--quoting-style=escape`")
                 .overrides_with_all(&[
@@ -809,8 +968,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::quoting::C)
-                .short("Q")
+            Arg::new(options::quoting::C)
+                .short('Q')
                 .long(options::quoting::C)
                 .help("Use C quoting style. Equivalent to `--quoting-style=c`")
                 .overrides_with_all(&[
@@ -822,21 +981,21 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         // Control characters
         .arg(
-            Arg::with_name(options::HIDE_CONTROL_CHARS)
-                .short("q")
+            Arg::new(options::HIDE_CONTROL_CHARS)
+                .short('q')
                 .long(options::HIDE_CONTROL_CHARS)
                 .help("Replace control characters with '?' if they are not escaped.")
                 .overrides_with_all(&[options::HIDE_CONTROL_CHARS, options::SHOW_CONTROL_CHARS]),
         )
         .arg(
-            Arg::with_name(options::SHOW_CONTROL_CHARS)
+            Arg::new(options::SHOW_CONTROL_CHARS)
                 .long(options::SHOW_CONTROL_CHARS)
                 .help("Show control characters 'as is' if they are not escaped.")
                 .overrides_with_all(&[options::HIDE_CONTROL_CHARS, options::SHOW_CONTROL_CHARS]),
         )
         // Time arguments
         .arg(
-            Arg::with_name(options::TIME)
+            Arg::new(options::TIME)
                 .long(options::TIME)
                 .help(
                     "Show time in <field>:\n\
@@ -854,8 +1013,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .overrides_with_all(&[options::TIME, options::time::ACCESS, options::time::CHANGE]),
         )
         .arg(
-            Arg::with_name(options::time::CHANGE)
-                .short(options::time::CHANGE)
+            Arg::new(options::time::CHANGE)
+                .short('c')
                 .help(
                     "If the long listing format (e.g., -l, -o) is being used, print the status \
                 change time (the 'ctime' in the inode) instead of the modification time. When \
@@ -865,8 +1024,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .overrides_with_all(&[options::TIME, options::time::ACCESS, options::time::CHANGE]),
         )
         .arg(
-            Arg::with_name(options::time::ACCESS)
-                .short(options::time::ACCESS)
+            Arg::new(options::time::ACCESS)
+                .short('u')
                 .help(
                     "If the long listing format (e.g., -l, -o) is being used, print the status \
                 access time instead of the modification time. When explicitly sorting by time \
@@ -877,33 +1036,33 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         // Hide and ignore
         .arg(
-            Arg::with_name(options::HIDE)
+            Arg::new(options::HIDE)
                 .long(options::HIDE)
                 .takes_value(true)
-                .multiple(true)
+                .multiple_occurrences(true)
                 .value_name("PATTERN")
                 .help(
                     "do not list implied entries matching shell PATTERN (overridden by -a or -A)",
                 ),
         )
         .arg(
-            Arg::with_name(options::IGNORE)
-                .short("I")
+            Arg::new(options::IGNORE)
+                .short('I')
                 .long(options::IGNORE)
                 .takes_value(true)
-                .multiple(true)
+                .multiple_occurrences(true)
                 .value_name("PATTERN")
                 .help("do not list implied entries matching shell PATTERN"),
         )
         .arg(
-            Arg::with_name(options::IGNORE_BACKUPS)
-                .short("B")
+            Arg::new(options::IGNORE_BACKUPS)
+                .short('B')
                 .long(options::IGNORE_BACKUPS)
                 .help("Ignore entries which end with ~."),
         )
         // Sort arguments
         .arg(
-            Arg::with_name(options::SORT)
+            Arg::new(options::SORT)
                 .long(options::SORT)
                 .help("Sort by <field>: name, none (-U), time (-t), size (-S) or extension (-X)")
                 .value_name("field")
@@ -920,8 +1079,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::sort::SIZE)
-                .short(options::sort::SIZE)
+            Arg::new(options::sort::SIZE)
+                .short('S')
                 .help("Sort by file size, largest first.")
                 .overrides_with_all(&[
                     options::SORT,
@@ -933,8 +1092,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::sort::TIME)
-                .short(options::sort::TIME)
+            Arg::new(options::sort::TIME)
+                .short('t')
                 .help("Sort by modification time (the 'mtime' in the inode), newest first.")
                 .overrides_with_all(&[
                     options::SORT,
@@ -946,8 +1105,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::sort::VERSION)
-                .short(options::sort::VERSION)
+            Arg::new(options::sort::VERSION)
+                .short('v')
                 .help("Natural sort of (version) numbers in the filenames.")
                 .overrides_with_all(&[
                     options::SORT,
@@ -959,8 +1118,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::sort::EXTENSION)
-                .short(options::sort::EXTENSION)
+            Arg::new(options::sort::EXTENSION)
+                .short('X')
                 .help("Sort alphabetically by entry extension.")
                 .overrides_with_all(&[
                     options::SORT,
@@ -972,8 +1131,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::sort::NONE)
-                .short(options::sort::NONE)
+            Arg::new(options::sort::NONE)
+                .short('U')
                 .help(
                     "Do not sort; list the files in whatever order they are stored in the \
     directory.  This is especially useful when listing very large directories, \
@@ -990,8 +1149,8 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         // Dereferencing
         .arg(
-            Arg::with_name(options::dereference::ALL)
-                .short("L")
+            Arg::new(options::dereference::ALL)
+                .short('L')
                 .long(options::dereference::ALL)
                 .help(
                     "When showing file information for a symbolic link, show information for the \
@@ -1004,7 +1163,7 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::dereference::DIR_ARGS)
+            Arg::new(options::dereference::DIR_ARGS)
                 .long(options::dereference::DIR_ARGS)
                 .help(
                     "Do not dereference symlinks except when they link to directories and are \
@@ -1017,8 +1176,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::dereference::ARGS)
-                .short("H")
+            Arg::new(options::dereference::ARGS)
+                .short('H')
                 .long(options::dereference::ARGS)
                 .help("Do not dereference symlinks except when given as command line arguments.")
                 .overrides_with_all(&[
@@ -1029,34 +1188,40 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         // Long format options
         .arg(
-            Arg::with_name(options::NO_GROUP)
+            Arg::new(options::NO_GROUP)
                 .long(options::NO_GROUP)
-                .short("-G")
+                .short('G')
                 .help("Do not show group in long format."),
         )
-        .arg(Arg::with_name(options::AUTHOR).long(options::AUTHOR).help(
+        .arg(Arg::new(options::AUTHOR).long(options::AUTHOR).help(
             "Show author in long format. \
             On the supported platforms, the author always matches the file owner.",
         ))
         // Other Flags
         .arg(
-            Arg::with_name(options::files::ALL)
-                .short("a")
+            Arg::new(options::files::ALL)
+                .short('a')
                 .long(options::files::ALL)
+                // Overrides -A (as the order matters)
+                .overrides_with(options::files::ALMOST_ALL)
+                .multiple_occurrences(true)
                 .help("Do not ignore hidden files (files with names that start with '.')."),
         )
         .arg(
-            Arg::with_name(options::files::ALMOST_ALL)
-                .short("A")
+            Arg::new(options::files::ALMOST_ALL)
+                .short('A')
                 .long(options::files::ALMOST_ALL)
+                // Overrides -a (as the order matters)
+                .overrides_with(options::files::ALL)
+                .multiple_occurrences(true)
                 .help(
                     "In a directory, do not ignore all file names that start with '.', \
 only ignore '.' and '..'.",
                 ),
         )
         .arg(
-            Arg::with_name(options::DIRECTORY)
-                .short("d")
+            Arg::new(options::DIRECTORY)
+                .short('d')
                 .long(options::DIRECTORY)
                 .help(
                     "Only list the names of directories, rather than listing directory contents. \
@@ -1066,26 +1231,40 @@ only ignore '.' and '..'.",
                 ),
         )
         .arg(
-            Arg::with_name(options::size::HUMAN_READABLE)
-                .short("h")
+            Arg::new(options::size::HUMAN_READABLE)
+                .short('h')
                 .long(options::size::HUMAN_READABLE)
                 .help("Print human readable file sizes (e.g. 1K 234M 56G).")
                 .overrides_with(options::size::SI),
         )
         .arg(
-            Arg::with_name(options::size::SI)
+            Arg::new(options::size::KIBIBYTES)
+                .short('k')
+                .long(options::size::KIBIBYTES)
+                .help("default to 1024-byte blocks for file system usage; used only with -s and per directory totals"),
+        )
+        .arg(
+            Arg::new(options::size::SI)
                 .long(options::size::SI)
                 .help("Print human readable file sizes using powers of 1000 instead of 1024."),
         )
         .arg(
-            Arg::with_name(options::INODE)
-                .short("i")
+            Arg::new(options::size::BLOCK_SIZE)
+                .long(options::size::BLOCK_SIZE)
+                .takes_value(true)
+                .require_equals(true)
+                .value_name("BLOCK_SIZE")
+                .help("scale sizes by BLOCK_SIZE when printing them"),
+        )
+        .arg(
+            Arg::new(options::INODE)
+                .short('i')
                 .long(options::INODE)
                 .help("print the index number of each file"),
         )
         .arg(
-            Arg::with_name(options::REVERSE)
-                .short("r")
+            Arg::new(options::REVERSE)
+                .short('r')
                 .long(options::REVERSE)
                 .help(
                     "Reverse whatever the sorting method is e.g., list files in reverse \
@@ -1093,29 +1272,38 @@ only ignore '.' and '..'.",
                 ),
         )
         .arg(
-            Arg::with_name(options::RECURSIVE)
-                .short("R")
+            Arg::new(options::RECURSIVE)
+                .short('R')
                 .long(options::RECURSIVE)
                 .help("List the contents of all directories recursively."),
         )
         .arg(
-            Arg::with_name(options::WIDTH)
+            Arg::new(options::WIDTH)
                 .long(options::WIDTH)
-                .short("w")
+                .short('w')
                 .help("Assume that the terminal is COLS columns wide.")
                 .value_name("COLS")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::COLOR)
+            Arg::new(options::size::ALLOCATION_SIZE)
+                .short('s')
+                .long(options::size::ALLOCATION_SIZE)
+                .help("print the allocated size of each file, in blocks"),
+        )
+        .arg(
+            Arg::new(options::COLOR)
                 .long(options::COLOR)
                 .help("Color output based on file type.")
                 .takes_value(true)
+                .possible_values(&[
+                    "always", "yes", "force", "auto", "tty", "if-tty", "never", "no", "none",
+                ])
                 .require_equals(true)
                 .min_values(0),
         )
         .arg(
-            Arg::with_name(options::INDICATOR_STYLE)
+            Arg::new(options::INDICATOR_STYLE)
                 .long(options::INDICATOR_STYLE)
                 .help(
                     "Append indicator with style WORD to entry names: \
@@ -1131,15 +1319,34 @@ only ignore '.' and '..'.",
                 ]),
         )
         .arg(
-            Arg::with_name(options::indicator_style::CLASSIFY)
-                .short("F")
+            // The --classify flag can take an optional when argument to
+            // control its behavior from version 9 of GNU coreutils.
+            // There is currently an inconsistency where GNU coreutils allows only
+            // the long form of the flag to take the argument while we allow it
+            // for both the long and short form of the flag.
+            Arg::new(options::indicator_style::CLASSIFY)
+                .short('F')
                 .long(options::indicator_style::CLASSIFY)
                 .help(
                     "Append a character to each file name indicating the file type. Also, for \
                 regular files that are executable, append '*'. The file type indicators are \
                 '/' for directories, '@' for symbolic links, '|' for FIFOs, '=' for sockets, \
-                '>' for doors, and nothing for regular files.",
+                '>' for doors, and nothing for regular files. when may be omitted, or one of:\n\
+                    \tnone - Do not classify. This is the default.\n\
+                    \tauto - Only classify if standard output is a terminal.\n\
+                    \talways - Always classify.\n\
+                Specifying --classify and no when is equivalent to --classify=always. This will not follow\
+                symbolic links listed on the command line unless the --dereference-command-line (-H),\
+                --dereference (-L), or --dereference-command-line-symlink-to-dir options are specified.",
                 )
+                .takes_value(true)
+                .value_name("when")
+                .possible_values(&[
+                    "always", "yes", "force", "auto", "tty", "if-tty", "never", "no", "none",
+                ])
+                .default_missing_value("always")
+                .require_equals(true)
+                .min_values(0)
                 .overrides_with_all(&[
                     options::indicator_style::FILE_TYPE,
                     options::indicator_style::SLASH,
@@ -1148,7 +1355,7 @@ only ignore '.' and '..'.",
                 ]),
         )
         .arg(
-            Arg::with_name(options::indicator_style::FILE_TYPE)
+            Arg::new(options::indicator_style::FILE_TYPE)
                 .long(options::indicator_style::FILE_TYPE)
                 .help("Same as --classify, but do not append '*'")
                 .overrides_with_all(&[
@@ -1159,8 +1366,8 @@ only ignore '.' and '..'.",
                 ]),
         )
         .arg(
-            Arg::with_name(options::indicator_style::SLASH)
-                .short(options::indicator_style::SLASH)
+            Arg::new(options::indicator_style::SLASH)
+                .short('p')
                 .help("Append / indicator to directories.")
                 .overrides_with_all(&[
                     options::indicator_style::FILE_TYPE,
@@ -1171,7 +1378,7 @@ only ignore '.' and '..'.",
         )
         .arg(
             //This still needs support for posix-*, +FORMAT
-            Arg::with_name(options::TIME_STYLE)
+            Arg::new(options::TIME_STYLE)
                 .long(options::TIME_STYLE)
                 .help("time/date format with -l; see TIME_STYLE below")
                 .value_name("TIME_STYLE")
@@ -1180,22 +1387,23 @@ only ignore '.' and '..'.",
                 .overrides_with_all(&[options::TIME_STYLE]),
         )
         .arg(
-            Arg::with_name(options::FULL_TIME)
+            Arg::new(options::FULL_TIME)
                 .long(options::FULL_TIME)
                 .overrides_with(options::FULL_TIME)
                 .help("like -l --time-style=full-iso"),
         )
         .arg(
-            Arg::with_name(options::CONTEXT)
-                .short("Z")
+            Arg::new(options::CONTEXT)
+                .short('Z')
                 .long(options::CONTEXT)
                 .help(CONTEXT_HELP_TEXT),
         )
         // Positional arguments
         .arg(
-            Arg::with_name(options::PATHS)
-                .multiple(true)
-                .takes_value(true),
+            Arg::new(options::PATHS)
+                .multiple_occurrences(true)
+                .takes_value(true)
+                .allow_invalid_utf8(true),
         )
         .after_help(
             "The TIME_STYLE argument can be full-iso, long-iso, iso. \
@@ -1203,13 +1411,15 @@ only ignore '.' and '..'.",
         )
 }
 
-/// Represents a Path along with it's associated data
-/// Any data that will be reused several times makes sense to be added to this structure
-/// Caching data here helps eliminate redundant syscalls to fetch same information
+/// Represents a Path along with it's associated data.
+/// Any data that will be reused several times makes sense to be added to this structure.
+/// Caching data here helps eliminate redundant syscalls to fetch same information.
+#[derive(Debug)]
 struct PathData {
     // Result<MetaData> got from symlink_metadata() or metadata() based on config
     md: OnceCell<Option<Metadata>>,
     ft: OnceCell<Option<FileType>>,
+    de: Option<DirEntry>,
     // Name of the file - will be empty for . or ..
     display_name: OsString,
     // PathBuf that all above data corresponds to
@@ -1221,7 +1431,7 @@ struct PathData {
 impl PathData {
     fn new(
         p_buf: PathBuf,
-        file_type: Option<std::io::Result<FileType>>,
+        dir_entry: Option<std::io::Result<DirEntry>>,
         file_name: Option<OsString>,
         config: &Config,
         command_line: bool,
@@ -1254,8 +1464,24 @@ impl PathData {
             }
             Dereference::None => false,
         };
-        let ft = match file_type {
-            Some(ft) => OnceCell::from(ft.ok()),
+
+        let de: Option<DirEntry> = match dir_entry {
+            Some(de) => de.ok(),
+            None => None,
+        };
+
+        // Why prefer to check the DirEntry file_type()?  B/c the call is
+        // nearly free compared to a metadata() call on a Path
+        let ft = match de {
+            Some(ref de) => {
+                if let Ok(ft_de) = de.file_type() {
+                    OnceCell::from(Some(ft_de))
+                } else if let Ok(md_pb) = p_buf.metadata() {
+                    OnceCell::from(Some(md_pb.file_type()))
+                } else {
+                    OnceCell::new()
+                }
+            }
             None => OnceCell::new(),
         };
 
@@ -1268,6 +1494,7 @@ impl PathData {
         Self {
             md: OnceCell::new(),
             ft,
+            de,
             display_name,
             p_buf,
             must_dereference,
@@ -1275,42 +1502,67 @@ impl PathData {
         }
     }
 
-    fn md(&self) -> Option<&Metadata> {
+    fn md(&self, out: &mut BufWriter<Stdout>) -> Option<&Metadata> {
         self.md
-            .get_or_init(|| get_metadata(&self.p_buf, self.must_dereference).ok())
+            .get_or_init(|| {
+                // check if we can use DirEntry metadata
+                if !self.must_dereference {
+                    if let Some(dir_entry) = &self.de {
+                        return dir_entry.metadata().ok();
+                    }
+                }
+
+                // if not, check if we can use Path metadata
+                match get_metadata(self.p_buf.as_path(), self.must_dereference) {
+                    Err(err) => {
+                        // FIXME: A bit tricky to propagate the result here
+                        out.flush().unwrap();
+                        let errno = err.raw_os_error().unwrap_or(1i32);
+                        // a bad fd will throw an error when dereferenced,
+                        // but GNU will not throw an error until a bad fd "dir"
+                        // is entered, here we match that GNU behavior, by handing
+                        // back the non-dereferenced metadata upon an EBADF
+                        if self.must_dereference && errno == 9i32 {
+                            if let Some(dir_entry) = &self.de {
+                                return dir_entry.metadata().ok();
+                            }
+                        }
+                        show!(LsError::IOErrorContext(err, self.p_buf.clone(),));
+                        None
+                    }
+                    Ok(md) => Some(md),
+                }
+            })
             .as_ref()
     }
 
-    fn file_type(&self) -> Option<&FileType> {
+    fn file_type(&self, out: &mut BufWriter<Stdout>) -> Option<&FileType> {
         self.ft
-            .get_or_init(|| self.md().map(|md| md.file_type()))
+            .get_or_init(|| self.md(out).map(|md| md.file_type()))
             .as_ref()
     }
 }
 
-fn list(locs: Vec<&Path>, config: Config) -> UResult<()> {
+fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
     let mut files = Vec::<PathData>::new();
     let mut dirs = Vec::<PathData>::new();
-
     let mut out = BufWriter::new(stdout());
+    let initial_locs_len = locs.len();
 
-    for loc in &locs {
-        let p = PathBuf::from(loc);
-        let path_data = PathData::new(p, None, None, &config, true);
+    for loc in locs {
+        let path_data = PathData::new(PathBuf::from(loc), None, None, config, true);
 
-        if path_data.md().is_none() {
-            // FIXME: Would be nice to use the actual error instead of hardcoding it
-            // Presumably other errors can happen too?
-            show_error!(
-                "cannot access {}: No such file or directory",
-                path_data.p_buf.quote()
-            );
-            set_exit_code(1);
-            // We found an error, no need to continue the execution
+        // Getting metadata here is no big deal as it's just the CWD
+        // and we really just want to know if the strings exist as files/dirs
+        //
+        // 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() {
             continue;
         }
 
-        let show_dir_contents = match path_data.file_type() {
+        let show_dir_contents = match path_data.file_type(&mut out) {
             Some(ft) => !config.directory && ft.is_dir(),
             None => {
                 set_exit_code(1);
@@ -1324,33 +1576,49 @@ fn list(locs: Vec<&Path>, config: Config) -> UResult<()> {
             files.push(path_data);
         }
     }
-    sort_entries(&mut files, &config);
-    display_items(&files, &config, &mut out);
 
-    sort_entries(&mut dirs, &config);
-    for dir in dirs {
-        if locs.len() > 1 || config.recursive {
-            // FIXME: This should use the quoting style and propagate errors
-            let _ = writeln!(out, "\n{}:", dir.p_buf.display());
+    sort_entries(&mut files, config, &mut out);
+    sort_entries(&mut dirs, config, &mut out);
+
+    display_items(&files, config, &mut out)?;
+
+    for (pos, path_data) in dirs.iter().enumerate() {
+        // Do read_dir call here to match GNU semantics by printing
+        // read_dir errors before directory headings, names and totals
+        let read_dir = match fs::read_dir(&path_data.p_buf) {
+            Err(err) => {
+                // flush stdout buffer before the error to preserve formatting and order
+                out.flush()?;
+                show!(LsError::IOErrorContext(err, path_data.p_buf.clone()));
+                continue;
+            }
+            Ok(rd) => rd,
+        };
+
+        // Print dir heading - name... 'total' comes after error display
+        if initial_locs_len > 1 || config.recursive {
+            if pos.eq(&0usize) && files.is_empty() {
+                writeln!(out, "{}:", path_data.p_buf.display())?;
+            } else {
+                writeln!(out, "\n{}:", path_data.p_buf.display())?;
+            }
         }
-        enter_directory(&dir, &config, &mut out);
+        enter_directory(path_data, read_dir, config, &mut out)?;
     }
 
     Ok(())
 }
 
-fn sort_entries(entries: &mut Vec<PathData>, config: &Config) {
+fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<Stdout>) {
     match config.sort {
         Sort::Time => entries.sort_by_key(|k| {
             Reverse(
-                k.md()
+                k.md(out)
                     .and_then(|md| get_system_time(md, config))
                     .unwrap_or(UNIX_EPOCH),
             )
         }),
-        Sort::Size => {
-            entries.sort_by_key(|k| Reverse(k.md().as_ref().map(|md| md.len()).unwrap_or(0)))
-        }
+        Sort::Size => entries.sort_by_key(|k| Reverse(k.md(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
@@ -1369,87 +1637,157 @@ fn sort_entries(entries: &mut Vec<PathData>, config: &Config) {
     }
 }
 
-#[cfg(windows)]
 fn is_hidden(file_path: &DirEntry) -> bool {
-    let path = file_path.path();
-    let metadata = fs::metadata(&path).unwrap_or_else(|_| fs::symlink_metadata(&path).unwrap());
-    let attr = metadata.file_attributes();
-    (attr & 0x2) > 0
+    #[cfg(windows)]
+    {
+        let metadata = file_path.metadata().unwrap();
+        let attr = metadata.file_attributes();
+        (attr & 0x2) > 0
+    }
+    #[cfg(not(windows))]
+    {
+        file_path
+            .file_name()
+            .to_str()
+            .map(|res| res.starts_with('.'))
+            .unwrap_or(false)
+    }
 }
 
 fn should_display(entry: &DirEntry, config: &Config) -> bool {
-    let ffi_name = entry.file_name();
-
-    // For unix, the hidden files are already included in the ignore pattern
-    #[cfg(windows)]
-    {
-        if config.files == Files::Normal && is_hidden(entry) {
-            return false;
-        }
+    // check if hidden
+    if config.files == Files::Normal && is_hidden(entry) {
+        return false;
     }
 
-    !config.ignore_patterns.is_match(&ffi_name)
+    // check if explicitly ignored
+    for pattern in &config.ignore_patterns {
+        if pattern.matches(entry.file_name().to_str().unwrap()) {
+            return false;
+        };
+        continue;
+    }
+
+    // else default to display
+    true
 }
 
-fn enter_directory(dir: &PathData, config: &Config, out: &mut BufWriter<Stdout>) {
-    let mut entries: Vec<_> = if config.files == Files::All {
+fn enter_directory(
+    path_data: &PathData,
+    read_dir: ReadDir,
+    config: &Config,
+    out: &mut BufWriter<Stdout>,
+) -> UResult<()> {
+    // Create vec of entries with initial dot files
+    let mut entries: Vec<PathData> = if config.files == Files::All {
         vec![
             PathData::new(
-                dir.p_buf.clone(),
-                Some(Ok(*dir.file_type().unwrap())),
+                path_data.p_buf.clone(),
+                None,
                 Some(".".into()),
                 config,
                 false,
             ),
-            PathData::new(dir.p_buf.join(".."), None, Some("..".into()), config, false),
+            PathData::new(
+                path_data.p_buf.join(".."),
+                None,
+                Some("..".into()),
+                config,
+                false,
+            ),
         ]
     } else {
         vec![]
     };
 
-    let mut temp: Vec<_> = crash_if_err!(1, fs::read_dir(&dir.p_buf))
-        .map(|res| crash_if_err!(1, res))
-        .filter(|e| should_display(e, config))
-        .map(|e| PathData::new(DirEntry::path(&e), Some(e.file_type()), None, config, false))
-        .collect();
+    // Convert those entries to the PathData struct
+    let mut vec_path_data = Vec::new();
 
-    sort_entries(&mut temp, config);
+    for raw_entry in read_dir {
+        let dir_entry = match raw_entry {
+            Ok(path) => path,
+            Err(err) => {
+                out.flush()?;
+                show!(LsError::IOError(err));
+                continue;
+            }
+        };
 
-    entries.append(&mut temp);
+        if should_display(&dir_entry, config) {
+            let entry_path_data =
+                PathData::new(dir_entry.path(), Some(Ok(dir_entry)), None, config, false);
+            vec_path_data.push(entry_path_data);
+        };
+    }
 
-    display_items(&entries, config, out);
+    sort_entries(&mut vec_path_data, config, out);
+    entries.append(&mut vec_path_data);
+
+    // Print total after any error display
+    if config.format == Format::Long || config.alloc_size {
+        display_total(&entries, config, out)?;
+    }
+
+    display_items(&entries, config, out)?;
 
     if config.recursive {
         for e in entries
             .iter()
             .skip(if config.files == Files::All { 2 } else { 0 })
-            .filter(|p| p.file_type().map(|ft| ft.is_dir()).unwrap_or(false))
+            .filter(|p| p.ft.get().is_some())
+            .filter(|p| p.ft.get().unwrap().is_some())
+            .filter(|p| p.ft.get().unwrap().unwrap().is_dir())
         {
-            let _ = writeln!(out, "\n{}:", e.p_buf.display());
-            enter_directory(e, config, out);
+            match fs::read_dir(&e.p_buf) {
+                Err(err) => {
+                    out.flush()?;
+                    show!(LsError::IOErrorContext(err, e.p_buf.clone()));
+                    continue;
+                }
+                Ok(rd) => {
+                    writeln!(out, "\n{}:", e.p_buf.display())?;
+                    enter_directory(e, rd, config, out)?;
+                }
+            }
         }
     }
+
+    Ok(())
 }
 
-fn get_metadata(entry: &Path, dereference: bool) -> std::io::Result<Metadata> {
+fn get_metadata(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
     if dereference {
-        entry.metadata()
+        p_buf.metadata()
     } else {
-        entry.symlink_metadata()
+        p_buf.symlink_metadata()
     }
 }
 
-fn display_dir_entry_size(entry: &PathData, config: &Config) -> (usize, usize, usize, usize) {
+fn display_dir_entry_size(
+    entry: &PathData,
+    config: &Config,
+    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() {
+    if let Some(md) = entry.md(out) {
+        let (size_len, major_len, minor_len) = match display_len_or_rdev(md, config) {
+            SizeOrDeviceId::Device(major, minor) => (
+                (major.len() + minor.len() + 2usize),
+                major.len(),
+                minor.len(),
+            ),
+            SizeOrDeviceId::Size(size) => (size.len(), 0usize, 0usize),
+        };
         (
             display_symlink_count(md).len(),
             display_uname(md, config).len(),
             display_group(md, config).len(),
-            display_size_or_rdev(md, config).len(),
+            size_len,
+            major_len,
+            minor_len,
         )
     } else {
-        (0, 0, 0, 0)
+        (0, 0, 0, 0, 0, 0)
     }
 }
 
@@ -1461,53 +1799,70 @@ fn pad_right(string: &str, count: usize) -> String {
     format!("{:<width$}", string, width = count)
 }
 
-fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) {
+fn display_total(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) -> UResult<()> {
+    let mut total_size = 0;
+    for item in items {
+        total_size += item
+            .md(out)
+            .as_ref()
+            .map_or(0, |md| get_block_size(md, config));
+    }
+    writeln!(out, "total {}", display_size(total_size, config))?;
+    Ok(())
+}
+
+fn display_additional_leading_info(
+    item: &PathData,
+    padding: &PaddingCollection,
+    config: &Config,
+    out: &mut BufWriter<Stdout>,
+) -> UResult<String> {
+    let mut result = String::new();
+    #[cfg(unix)]
+    {
+        if config.inode {
+            let i = if let Some(md) = item.md(out) {
+                get_inode(md)
+            } else {
+                "?".to_owned()
+            };
+            result.push_str(&format!("{} ", pad_left(&i, padding.inode)));
+        }
+    }
+
+    if config.alloc_size {
+        let s = if let Some(md) = item.md(out) {
+            display_size(get_block_size(md, config), config)
+        } else {
+            "?".to_owned()
+        };
+        result.push_str(&format!("{} ", pad_left(&s, padding.block_size),));
+    }
+    Ok(result)
+}
+
+fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) -> 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.
 
     if config.format == Format::Long {
-        let (
-            mut longest_link_count_len,
-            mut longest_uname_len,
-            mut longest_group_len,
-            mut longest_context_len,
-            mut longest_size_len,
-        ) = (1, 1, 1, 1, 1);
-        let mut total_size = 0;
+        let padding_collection = calculate_padding_collection(items, config, out);
 
         for item in items {
-            let context_len = item.security_context.len();
-            let (link_count_len, uname_len, group_len, size_len) =
-                display_dir_entry_size(item, config);
-            longest_link_count_len = link_count_len.max(longest_link_count_len);
-            longest_size_len = size_len.max(longest_size_len);
-            longest_uname_len = uname_len.max(longest_uname_len);
-            longest_group_len = group_len.max(longest_group_len);
-            if config.context {
-                longest_context_len = context_len.max(longest_context_len);
+            #[cfg(unix)]
+            if config.inode || config.alloc_size {
+                let more_info =
+                    display_additional_leading_info(item, &padding_collection, config, out)?;
+                write!(out, "{}", more_info)?;
             }
-            longest_size_len = size_len.max(longest_size_len);
-            total_size += item.md().map_or(0, |md| get_block_size(md, config));
-        }
-
-        if total_size > 0 {
-            let _ = writeln!(out, "total {}", display_size(total_size, config));
-        }
-
-        for item in items {
-            display_item_long(
-                item,
-                PaddingCollection {
-                    longest_link_count_len,
-                    longest_uname_len,
-                    longest_group_len,
-                    longest_context_len,
-                    longest_size_len,
-                },
-                config,
-                out,
-            );
+            #[cfg(not(unix))]
+            if config.alloc_size {
+                let more_info =
+                    display_additional_leading_info(item, &padding_collection, config, out)?;
+                write!(out, "{}", more_info)?;
+            }
+            display_item_long(item, &padding_collection, config, out)?;
         }
     } else {
         let mut longest_context_len = 1;
@@ -1520,18 +1875,27 @@ fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout
         } else {
             None
         };
-        let names = items
-            .iter()
-            .filter_map(|i| display_file_name(i, config, prefix_context));
+
+        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);
+            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)?,
+            Format::Across => display_grid(names, config.width, Direction::LeftToRight, out)?,
             Format::Commas => {
                 let mut current_col = 0;
                 let mut names = names;
                 if let Some(name) = names.next() {
-                    let _ = write!(out, "{}", name.contents);
+                    write!(out, "{}", name.contents)?;
                     current_col = name.width as u16 + 2;
                 }
                 for name in names {
@@ -1539,45 +1903,58 @@ fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout
                     // If the width is 0 we print one single line
                     if config.width != 0 && current_col + name_width + 1 > config.width {
                         current_col = name_width + 2;
-                        let _ = write!(out, ",\n{}", name.contents);
+                        write!(out, ",\n{}", name.contents)?;
                     } else {
                         current_col += name_width + 2;
-                        let _ = write!(out, ", {}", name.contents);
+                        write!(out, ", {}", name.contents)?;
                     }
                 }
                 // Current col is never zero again if names have been printed.
                 // So we print a newline.
                 if current_col > 0 {
-                    let _ = writeln!(out,);
+                    writeln!(out,)?;
                 }
             }
             _ => {
                 for name in names {
-                    let _ = writeln!(out, "{}", name.contents);
+                    writeln!(out, "{}", name.contents)?;
                 }
             }
-        }
+        };
     }
+
+    Ok(())
 }
 
+#[allow(unused_variables)]
 fn get_block_size(md: &Metadata, config: &Config) -> u64 {
     /* GNU ls will display sizes in terms of block size
        md.len() will differ from this value when the file has some holes
     */
     #[cfg(unix)]
     {
-        // hard-coded for now - enabling setting this remains a TODO
-        let ls_block_size = 1024;
+        let raw_blocks = if md.file_type().is_char_device() || md.file_type().is_block_device() {
+            0u64
+        } else {
+            md.blocks() * 512
+        };
         match config.size_format {
-            SizeFormat::Binary => md.blocks() * 512,
-            SizeFormat::Decimal => md.blocks() * 512,
-            SizeFormat::Bytes => md.blocks() * 512 / ls_block_size,
+            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
+                }
+            }
         }
     }
-
     #[cfg(not(unix))]
     {
-        let _ = config;
         // no way to get block size for windows, fall-back to file size
         md.len()
     }
@@ -1588,19 +1965,19 @@ fn display_grid(
     width: u16,
     direction: Direction,
     out: &mut BufWriter<Stdout>,
-) {
+) -> UResult<()> {
     if width == 0 {
         // If the width is 0 we print one single line
         let mut printed_something = false;
         for name in names {
             if printed_something {
-                let _ = write!(out, "  ");
+                write!(out, "  ")?;
             }
             printed_something = true;
-            let _ = write!(out, "{}", name.contents);
+            write!(out, "{}", name.contents)?;
         }
         if printed_something {
-            let _ = writeln!(out);
+            writeln!(out)?;
         }
     } else {
         let mut grid = Grid::new(GridOptions {
@@ -1614,14 +1991,15 @@ fn display_grid(
 
         match grid.fit_into_width(width as usize) {
             Some(output) => {
-                let _ = write!(out, "{}", output);
+                write!(out, "{}", output)?;
             }
             // Width is too small for the grid, so we fit it in one column
             None => {
-                let _ = write!(out, "{}", grid.fit_into_columns(1));
+                write!(out, "{}", grid.fit_into_columns(1))?;
             }
         }
     }
+    Ok(())
 }
 
 /// This writes to the BufWriter out a single string of the output of `ls -l`.
@@ -1633,7 +2011,7 @@ fn display_grid(
 /// * `owner` ([`display_uname`], config-optional)
 /// * `group` ([`display_group`], config-optional)
 /// * `author` ([`display_uname`], config-optional)
-/// * `size / rdev` ([`display_size_or_rdev`])
+/// * `size / rdev` ([`display_len_or_rdev`])
 /// * `system_time` ([`get_system_time`])
 /// * `file_name` ([`display_file_name`])
 ///
@@ -1651,90 +2029,183 @@ fn display_grid(
 ///    longest_size_len: usize,
 /// ```
 /// that decide the maximum possible character count of each field.
+#[allow(clippy::write_literal)]
 fn display_item_long(
     item: &PathData,
-    padding: PaddingCollection,
+    padding: &PaddingCollection,
     config: &Config,
     out: &mut BufWriter<Stdout>,
-) {
-    let md = match item.md() {
-        None => {
-            show!(LsError::NoMetadata(item.p_buf.clone()));
-            return;
+) -> UResult<()> {
+    if let Some(md) = item.md(out) {
+        write!(
+            out,
+            "{}{} {}",
+            display_permissions(md, true),
+            if item.security_context.len() > 1 {
+                // GNU `ls` uses a "." character to indicate a file with a security context,
+                // but not other alternate access method.
+                "."
+            } else {
+                ""
+            },
+            pad_left(&display_symlink_count(md), padding.link_count)
+        )?;
+
+        if config.long.owner {
+            write!(
+                out,
+                " {}",
+                pad_right(&display_uname(md, config), padding.uname)
+            )?;
         }
-        Some(md) => md,
-    };
 
-    #[cfg(unix)]
-    {
-        if config.inode {
-            let _ = write!(out, "{} ", get_inode(md));
+        if config.long.group {
+            write!(
+                out,
+                " {}",
+                pad_right(&display_group(md, config), padding.group)
+            )?;
         }
-    }
 
-    let _ = write!(
-        out,
-        "{}{} {}",
-        display_permissions(md, true),
-        if item.security_context.len() > 1 {
-            // GNU `ls` uses a "." character to indicate a file with a security context,
-            // but not other alternate access method.
-            "."
-        } else {
-            ""
-        },
-        pad_left(&display_symlink_count(md), padding.longest_link_count_len),
-    );
+        if config.context {
+            write!(
+                out,
+                " {}",
+                pad_right(&item.security_context, padding.context)
+            )?;
+        }
 
-    if config.long.owner {
-        let _ = write!(
+        // Author is only different from owner on GNU/Hurd, so we reuse
+        // the owner, since GNU/Hurd is not currently supported by Rust.
+        if config.long.author {
+            write!(
+                out,
+                " {}",
+                pad_right(&display_uname(md, config), padding.uname)
+            )?;
+        }
+
+        match display_len_or_rdev(md, config) {
+            SizeOrDeviceId::Size(size) => {
+                write!(out, " {}", pad_left(&size, padding.size))?;
+            }
+            SizeOrDeviceId::Device(major, minor) => {
+                write!(
+                    out,
+                    " {}, {}",
+                    pad_left(
+                        &major,
+                        #[cfg(not(unix))]
+                        0usize,
+                        #[cfg(unix)]
+                        padding.major.max(
+                            padding
+                                .size
+                                .saturating_sub(padding.minor.saturating_add(2usize))
+                        )
+                    ),
+                    pad_left(
+                        &minor,
+                        #[cfg(not(unix))]
+                        0usize,
+                        #[cfg(unix)]
+                        padding.minor,
+                    ),
+                )?;
+            }
+        };
+
+        let dfn = display_file_name(item, config, None, "".to_owned(), out).contents;
+
+        writeln!(out, " {} {}", display_date(md, config), dfn)?;
+    } else {
+        #[cfg(unix)]
+        let leading_char = {
+            if let Some(Some(ft)) = item.ft.get() {
+                if ft.is_char_device() {
+                    "c"
+                } else if ft.is_block_device() {
+                    "b"
+                } else if ft.is_symlink() {
+                    "l"
+                } else if ft.is_dir() {
+                    "d"
+                } else {
+                    "-"
+                }
+            } else {
+                "-"
+            }
+        };
+        #[cfg(not(unix))]
+        let leading_char = {
+            if let Some(Some(ft)) = item.ft.get() {
+                if ft.is_symlink() {
+                    "l"
+                } else if ft.is_dir() {
+                    "d"
+                } else {
+                    "-"
+                }
+            } else {
+                "-"
+            }
+        };
+
+        write!(
             out,
-            " {}",
-            pad_right(&display_uname(md, config), padding.longest_uname_len)
-        );
-    }
+            "{}{} {}",
+            format_args!("{}?????????", leading_char),
+            if item.security_context.len() > 1 {
+                // GNU `ls` uses a "." character to indicate a file with a security context,
+                // but not other alternate access method.
+                "."
+            } else {
+                ""
+            },
+            pad_left("?", padding.link_count)
+        )?;
 
-    if config.long.group {
-        let _ = write!(
+        if config.long.owner {
+            write!(out, " {}", pad_right("?", padding.uname))?;
+        }
+
+        if config.long.group {
+            write!(out, " {}", pad_right("?", padding.group))?;
+        }
+
+        if config.context {
+            write!(
+                out,
+                " {}",
+                pad_right(&item.security_context, padding.context)
+            )?;
+        }
+
+        // Author is only different from owner on GNU/Hurd, so we reuse
+        // the owner, since GNU/Hurd is not currently supported by Rust.
+        if config.long.author {
+            write!(out, " {}", pad_right("?", padding.uname))?;
+        }
+
+        let dfn = display_file_name(item, config, None, "".to_owned(), out).contents;
+        let date_len = 12;
+
+        writeln!(
             out,
-            " {}",
-            pad_right(&display_group(md, config), padding.longest_group_len)
-        );
+            " {} {} {}",
+            pad_left("?", padding.size),
+            pad_left("?", date_len),
+            dfn,
+        )?;
     }
 
-    if config.context {
-        let _ = write!(
-            out,
-            " {}",
-            pad_right(&item.security_context, padding.longest_context_len)
-        );
-    }
-
-    // Author is only different from owner on GNU/Hurd, so we reuse
-    // the owner, since GNU/Hurd is not currently supported by Rust.
-    if config.long.author {
-        let _ = write!(
-            out,
-            " {}",
-            pad_right(&display_uname(md, config), padding.longest_uname_len)
-        );
-    }
-
-    let _ = writeln!(
-        out,
-        " {} {} {}",
-        pad_left(&display_size_or_rdev(md, config), padding.longest_size_len),
-        display_date(md, config),
-        // unwrap is fine because it fails when metadata is not available
-        // but we already know that it is because it's checked at the
-        // start of the function.
-        display_file_name(item, config, None).unwrap().contents,
-    );
+    Ok(())
 }
 
 #[cfg(unix)]
 fn get_inode(metadata: &Metadata) -> String {
-    format!("{:8}", metadata.ino())
+    format!("{}", metadata.ino())
 }
 
 // Currently getpwuid is `linux` target only. If it's broken out into
@@ -1865,7 +2336,7 @@ fn display_date(metadata: &Metadata, config: &Config) -> String {
 // 3. The human-readable format uses powers for 1024, but does not display the "i"
 //    that is commonly used to denote Kibi, Mebi, etc.
 // 4. Kibi and Kilo are denoted differently ("k" and "K", respectively)
-fn format_prefixed(prefixed: NumberPrefix<f64>) -> String {
+fn format_prefixed(prefixed: &NumberPrefix<f64>) -> String {
     match prefixed {
         NumberPrefix::Standalone(bytes) => bytes.to_string(),
         NumberPrefix::Prefixed(prefix, bytes) => {
@@ -1883,27 +2354,61 @@ fn format_prefixed(prefixed: NumberPrefix<f64>) -> String {
     }
 }
 
-fn display_size_or_rdev(metadata: &Metadata, config: &Config) -> String {
-    #[cfg(unix)]
+#[allow(dead_code)]
+enum SizeOrDeviceId {
+    Size(String),
+    Device(String, String),
+}
+
+fn display_len_or_rdev(metadata: &Metadata, config: &Config) -> SizeOrDeviceId {
+    #[cfg(any(target_os = "macos", target_os = "ios"))]
+    {
+        let ft = metadata.file_type();
+        if ft.is_char_device() || ft.is_block_device() {
+            let dev: u64 = metadata.rdev();
+            let major = (dev >> 24) as u8;
+            let minor = (dev & 0xff) as u8;
+            return SizeOrDeviceId::Device(major.to_string(), minor.to_string());
+        }
+    }
+    #[cfg(target_os = "linux")]
     {
         let ft = metadata.file_type();
         if ft.is_char_device() || ft.is_block_device() {
             let dev: u64 = metadata.rdev();
             let major = (dev >> 8) as u8;
-            let minor = dev as u8;
-            return format!("{}, {}", major, minor);
+            let minor = (dev & 0xff) as u8;
+            return SizeOrDeviceId::Device(major.to_string(), minor.to_string());
         }
     }
-
-    display_size(metadata.len(), config)
+    // 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))
+    }
 }
 
 fn display_size(size: u64, config: &Config) -> String {
     // NOTE: The human-readable behavior deviates from the GNU ls.
     // The GNU ls uses binary prefixes by default.
     match config.size_format {
-        SizeFormat::Binary => format_prefixed(NumberPrefix::binary(size as f64)),
-        SizeFormat::Decimal => format_prefixed(NumberPrefix::decimal(size as f64)),
+        SizeFormat::Binary => format_prefixed(&NumberPrefix::binary(size as f64)),
+        SizeFormat::Decimal => format_prefixed(&NumberPrefix::decimal(size as f64)),
         SizeFormat::Bytes => size.to_string(),
     }
 }
@@ -1918,8 +2423,8 @@ fn file_is_executable(md: &Metadata) -> bool {
     md.mode() & ((S_IXUSR | S_IXGRP | S_IXOTH) as u32) != 0
 }
 
-fn classify_file(path: &PathData) -> Option<char> {
-    let file_type = path.file_type()?;
+fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
+    let file_type = path.file_type(out)?;
 
     if file_type.is_dir() {
         Some('/')
@@ -1932,7 +2437,7 @@ fn classify_file(path: &PathData) -> Option<char> {
                 Some('=')
             } else if file_type.is_fifo() {
                 Some('|')
-            } else if file_type.is_file() && file_is_executable(path.md()?) {
+            } else if file_type.is_file() && file_is_executable(path.md(out).as_ref().unwrap()) {
                 Some('*')
             } else {
                 None
@@ -1956,31 +2461,36 @@ fn classify_file(path: &PathData) -> Option<char> {
 ///
 /// Note that non-unicode sequences in symlink targets are dealt with using
 /// [`std::path::Path::to_string_lossy`].
+#[allow(unused_variables)]
 fn display_file_name(
     path: &PathData,
     config: &Config,
     prefix_context: Option<usize>,
-) -> Option<Cell> {
+    more_info: String,
+    out: &mut BufWriter<Stdout>,
+) -> 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);
 
-    #[cfg(unix)]
-    {
-        if config.format != Format::Long && config.inode {
-            name = path.md().map_or_else(|| "?".to_string(), get_inode) + " " + &name;
-        }
-    }
-
     // We need to keep track of the width ourselves instead of letting term_grid
     // infer it because the color codes mess up term_grid's width calculation.
     let mut width = name.width();
 
     if let Some(ls_colors) = &config.color {
-        name = color_name(ls_colors, &path.p_buf, name, path.md()?);
+        if let Ok(metadata) = path.p_buf.symlink_metadata() {
+            name = color_name(ls_colors, &path.p_buf, &name, &metadata, config);
+        }
+    }
+
+    if config.format != Format::Long && !more_info.is_empty() {
+        // increment width here b/c name was given colors and name.width() is now the wrong
+        // size for display
+        width += more_info.width();
+        name = more_info + &name;
     }
 
     if config.indicator_style != IndicatorStyle::None {
-        let sym = classify_file(path);
+        let sym = classify_file(path, out);
 
         let char_opt = match config.indicator_style {
             IndicatorStyle::Classify => sym,
@@ -2007,7 +2517,10 @@ fn display_file_name(
         }
     }
 
-    if config.format == Format::Long && path.file_type()?.is_symlink() {
+    if config.format == Format::Long
+        && path.file_type(out).is_some()
+        && path.file_type(out).unwrap().is_symlink()
+    {
         if let Ok(target) = path.p_buf.read_link() {
             name.push_str(" -> ");
 
@@ -2030,20 +2543,34 @@ 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.
-                let target_metadata = match target_data.md() {
-                    Some(md) => md,
-                    None => path.md()?,
-                };
+                if path.md(out).is_none()
+                    && get_metadata(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().to_owned(),
+                    };
 
-                name.push_str(&color_name(
-                    ls_colors,
-                    &target_data.p_buf,
-                    target.to_string_lossy().into_owned(),
-                    target_metadata,
-                ));
+                    name.push_str(&color_name(
+                        ls_colors,
+                        &target_data.p_buf,
+                        &target.to_string_lossy(),
+                        &target_metadata,
+                        config,
+                    ));
+                }
             } else {
                 // If no coloring is required, we just use target as is.
-                name.push_str(&target.to_string_lossy());
+                // Apply the right quoting
+                name.push_str(&escape_name(target.as_os_str(), &config.quoting_style));
             }
         }
     }
@@ -2062,16 +2589,25 @@ fn display_file_name(
         }
     }
 
-    Some(Cell {
+    Cell {
         contents: name,
         width,
-    })
+    }
 }
 
-fn color_name(ls_colors: &LsColors, path: &Path, name: String, md: &Metadata) -> String {
+fn color_name(
+    ls_colors: &LsColors,
+    path: &Path,
+    name: &str,
+    md: &Metadata,
+    config: &Config,
+) -> String {
     match ls_colors.style_for_path_with_metadata(path, Some(md)) {
-        Some(style) => style.to_ansi_term_style().paint(name).to_string(),
-        None => name,
+        Some(style) => {
+            let p = escape_name(OsStr::new(&name), &config.quoting_style);
+            return style.to_ansi_term_style().paint(p).to_string();
+        }
+        None => escape_name(OsStr::new(&name), &config.quoting_style),
     }
 }
 
@@ -2087,6 +2623,11 @@ fn display_symlink_count(metadata: &Metadata) -> String {
     metadata.nlink().to_string()
 }
 
+#[cfg(unix)]
+fn display_inode(metadata: &Metadata) -> String {
+    get_inode(metadata)
+}
+
 // This returns the SELinux security context as UTF8 `String`.
 // In the long term this should be changed to `OsStr`, see discussions at #2621/#2656
 #[allow(unused_variables)]
@@ -2095,7 +2636,7 @@ fn get_security_context(config: &Config, p_buf: &Path, must_dereference: bool) -
     if config.selinux_supported {
         #[cfg(feature = "selinux")]
         {
-            match selinux::SecurityContext::of_path(p_buf, must_dereference, false) {
+            match selinux::SecurityContext::of_path(p_buf, must_dereference.to_owned(), false) {
                 Err(_r) => {
                     // TODO: show the actual reason why it failed
                     show_warning!("failed to get security context of: {}", p_buf.quote());
@@ -2103,11 +2644,9 @@ fn get_security_context(config: &Config, p_buf: &Path, must_dereference: bool) -
                 }
                 Ok(None) => substitute_string,
                 Ok(Some(context)) => {
-                    let mut context = context.as_bytes();
-                    if context.ends_with(&[0]) {
-                        // TODO: replace with `strip_prefix()` when MSRV >= 1.51
-                        context = &context[..context.len() - 1]
-                    };
+                    let context = context.as_bytes();
+
+                    let context = context.strip_suffix(&[0]).unwrap_or(context);
                     String::from_utf8(context.to_vec()).unwrap_or_else(|e| {
                         show_warning!(
                             "getting security context of: {}: {}",
@@ -2127,3 +2666,104 @@ fn get_security_context(config: &Config, p_buf: &Path, must_dereference: bool) -
         substitute_string
     }
 }
+
+#[cfg(unix)]
+fn calculate_padding_collection(
+    items: &[PathData],
+    config: &Config,
+    out: &mut BufWriter<Stdout>,
+) -> PaddingCollection {
+    let mut padding_collections = PaddingCollection {
+        inode: 1,
+        link_count: 1,
+        uname: 1,
+        group: 1,
+        context: 1,
+        size: 1,
+        major: 1,
+        minor: 1,
+        block_size: 1,
+    };
+
+    for item in items {
+        #[cfg(unix)]
+        if config.inode {
+            let inode_len = if let Some(md) = item.md(out) {
+                display_inode(md).len()
+            } else {
+                continue;
+            };
+            padding_collections.inode = inode_len.max(padding_collections.inode);
+        }
+
+        if config.alloc_size {
+            if let Some(md) = item.md(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);
+            }
+        }
+
+        if config.format == Format::Long {
+            let context_len = item.security_context.len();
+            let (link_count_len, uname_len, group_len, size_len, major_len, minor_len) =
+                display_dir_entry_size(item, config, out);
+            padding_collections.link_count = link_count_len.max(padding_collections.link_count);
+            padding_collections.uname = uname_len.max(padding_collections.uname);
+            padding_collections.group = group_len.max(padding_collections.group);
+            if config.context {
+                padding_collections.context = context_len.max(padding_collections.context);
+            }
+            if items.len() == 1usize {
+                padding_collections.size = 0usize;
+                padding_collections.major = 0usize;
+                padding_collections.minor = 0usize;
+            } else {
+                padding_collections.major = major_len.max(padding_collections.major);
+                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);
+            }
+        }
+    }
+
+    padding_collections
+}
+
+#[cfg(not(unix))]
+fn calculate_padding_collection(
+    items: &[PathData],
+    config: &Config,
+    out: &mut BufWriter<Stdout>,
+) -> PaddingCollection {
+    let mut padding_collections = PaddingCollection {
+        link_count: 1,
+        uname: 1,
+        group: 1,
+        context: 1,
+        size: 1,
+        block_size: 1,
+    };
+
+    for item in items {
+        if config.alloc_size {
+            if let Some(md) = item.md(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);
+            }
+        }
+
+        let context_len = item.security_context.len();
+        let (link_count_len, uname_len, group_len, size_len, _major_len, _minor_len) =
+            display_dir_entry_size(item, config, out);
+        padding_collections.link_count = link_count_len.max(padding_collections.link_count);
+        padding_collections.uname = uname_len.max(padding_collections.uname);
+        padding_collections.group = group_len.max(padding_collections.group);
+        if config.context {
+            padding_collections.context = context_len.max(padding_collections.context);
+        }
+        padding_collections.size = size_len.max(padding_collections.size);
+    }
+
+    padding_collections
+}
diff --git a/src/uu/ls/src/main.rs b/src/uu/ls/src/main.rs
index d867c3843..c2a935e6d 100644
--- a/src/uu/ls/src/main.rs
+++ b/src/uu/ls/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_ls);
+uucore::bin!(uu_ls);
diff --git a/src/uu/ls/src/quoting_style.rs b/src/uu/ls/src/quoting_style.rs
index 149733cf9..4900dc566 100644
--- a/src/uu/ls/src/quoting_style.rs
+++ b/src/uu/ls/src/quoting_style.rs
@@ -79,8 +79,8 @@ impl Iterator for EscapeOctal {
 }
 
 impl EscapeOctal {
-    fn from(c: char) -> EscapeOctal {
-        EscapeOctal {
+    fn from(c: char) -> Self {
+        Self {
             c,
             idx: 2,
             state: EscapeOctalState::Backslash,
@@ -363,7 +363,7 @@ mod tests {
         }
     }
 
-    fn check_names(name: &str, map: Vec<(&str, &str)>) {
+    fn check_names(name: &str, map: &[(&str, &str)]) {
         assert_eq!(
             map.iter()
                 .map(|(_, style)| escape_name(name.as_ref(), &get_style(style)))
@@ -378,7 +378,7 @@ mod tests {
     fn test_simple_names() {
         check_names(
             "one_two",
-            vec![
+            &[
                 ("one_two", "literal"),
                 ("one_two", "literal-show"),
                 ("one_two", "escape"),
@@ -397,7 +397,7 @@ mod tests {
     fn test_spaces() {
         check_names(
             "one two",
-            vec![
+            &[
                 ("one two", "literal"),
                 ("one two", "literal-show"),
                 ("one\\ two", "escape"),
@@ -413,7 +413,7 @@ mod tests {
 
         check_names(
             " one",
-            vec![
+            &[
                 (" one", "literal"),
                 (" one", "literal-show"),
                 ("\\ one", "escape"),
@@ -433,7 +433,7 @@ mod tests {
         // One double quote
         check_names(
             "one\"two",
-            vec![
+            &[
                 ("one\"two", "literal"),
                 ("one\"two", "literal-show"),
                 ("one\"two", "escape"),
@@ -450,7 +450,7 @@ mod tests {
         // One single quote
         check_names(
             "one\'two",
-            vec![
+            &[
                 ("one'two", "literal"),
                 ("one'two", "literal-show"),
                 ("one'two", "escape"),
@@ -467,7 +467,7 @@ mod tests {
         // One single quote and one double quote
         check_names(
             "one'two\"three",
-            vec![
+            &[
                 ("one'two\"three", "literal"),
                 ("one'two\"three", "literal-show"),
                 ("one'two\"three", "escape"),
@@ -484,7 +484,7 @@ mod tests {
         // Consecutive quotes
         check_names(
             "one''two\"\"three",
-            vec![
+            &[
                 ("one''two\"\"three", "literal"),
                 ("one''two\"\"three", "literal-show"),
                 ("one''two\"\"three", "escape"),
@@ -504,7 +504,7 @@ mod tests {
         // A simple newline
         check_names(
             "one\ntwo",
-            vec![
+            &[
                 ("one?two", "literal"),
                 ("one\ntwo", "literal-show"),
                 ("one\\ntwo", "escape"),
@@ -521,7 +521,7 @@ mod tests {
         // A control character followed by a special shell character
         check_names(
             "one\n&two",
-            vec![
+            &[
                 ("one?&two", "literal"),
                 ("one\n&two", "literal-show"),
                 ("one\\n&two", "escape"),
@@ -539,7 +539,7 @@ mod tests {
         // no importance for file names.
         check_names(
             "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F",
-            vec![
+            &[
                 ("????????????????", "literal"),
                 (
                     "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F",
@@ -577,7 +577,7 @@ mod tests {
         // The last 16 control characters.
         check_names(
             "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
-            vec![
+            &[
                 ("????????????????", "literal"),
                 (
                     "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
@@ -615,7 +615,7 @@ mod tests {
         // DEL
         check_names(
             "\x7F",
-            vec![
+            &[
                 ("?", "literal"),
                 ("\x7F", "literal-show"),
                 ("\\177", "escape"),
@@ -637,7 +637,7 @@ mod tests {
         // in other tests)
         check_names(
             "one?two",
-            vec![
+            &[
                 ("one?two", "literal"),
                 ("one?two", "literal-show"),
                 ("one?two", "escape"),
@@ -657,7 +657,7 @@ mod tests {
         // Escaped in C-style, but not in Shell-style escaping
         check_names(
             "one\\two",
-            vec![
+            &[
                 ("one\\two", "literal"),
                 ("one\\two", "literal-show"),
                 ("one\\\\two", "escape"),
@@ -672,34 +672,34 @@ mod tests {
 
     #[test]
     fn test_tilde_and_hash() {
-        check_names("~", vec![("'~'", "shell"), ("'~'", "shell-escape")]);
+        check_names("~", &[("'~'", "shell"), ("'~'", "shell-escape")]);
         check_names(
             "~name",
-            vec![("'~name'", "shell"), ("'~name'", "shell-escape")],
+            &[("'~name'", "shell"), ("'~name'", "shell-escape")],
         );
         check_names(
             "some~name",
-            vec![("some~name", "shell"), ("some~name", "shell-escape")],
+            &[("some~name", "shell"), ("some~name", "shell-escape")],
         );
-        check_names("name~", vec![("name~", "shell"), ("name~", "shell-escape")]);
+        check_names("name~", &[("name~", "shell"), ("name~", "shell-escape")]);
 
-        check_names("#", vec![("'#'", "shell"), ("'#'", "shell-escape")]);
+        check_names("#", &[("'#'", "shell"), ("'#'", "shell-escape")]);
         check_names(
             "#name",
-            vec![("'#name'", "shell"), ("'#name'", "shell-escape")],
+            &[("'#name'", "shell"), ("'#name'", "shell-escape")],
         );
         check_names(
             "some#name",
-            vec![("some#name", "shell"), ("some#name", "shell-escape")],
+            &[("some#name", "shell"), ("some#name", "shell-escape")],
         );
-        check_names("name#", vec![("name#", "shell"), ("name#", "shell-escape")]);
+        check_names("name#", &[("name#", "shell"), ("name#", "shell-escape")]);
     }
 
     #[test]
     fn test_special_chars_in_double_quotes() {
         check_names(
             "can'$t",
-            vec![
+            &[
                 ("'can'\\''$t'", "shell"),
                 ("'can'\\''$t'", "shell-always"),
                 ("'can'\\''$t'", "shell-escape"),
@@ -709,7 +709,7 @@ mod tests {
 
         check_names(
             "can'`t",
-            vec![
+            &[
                 ("'can'\\''`t'", "shell"),
                 ("'can'\\''`t'", "shell-always"),
                 ("'can'\\''`t'", "shell-escape"),
@@ -719,7 +719,7 @@ mod tests {
 
         check_names(
             "can'\\t",
-            vec![
+            &[
                 ("'can'\\''\\t'", "shell"),
                 ("'can'\\''\\t'", "shell-always"),
                 ("'can'\\''\\t'", "shell-escape"),
diff --git a/src/uu/mkdir/Cargo.toml b/src/uu/mkdir/Cargo.toml
index c0e6586ab..08b2f1aff 100644
--- a/src/uu/mkdir/Cargo.toml
+++ b/src/uu/mkdir/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_mkdir"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mkdir ~ (uutils) create DIRECTORY"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/mkdir"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mkdir"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,8 @@ edition = "2018"
 path = "src/mkdir.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs", "mode"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs", "mode"] }
 
 [[bin]]
 name = "mkdir"
diff --git a/src/uu/mkdir/LICENSE b/src/uu/mkdir/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/mkdir/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/mkdir/src/main.rs b/src/uu/mkdir/src/main.rs
index fa6855c93..e3ea12f79 100644
--- a/src/uu/mkdir/src/main.rs
+++ b/src/uu/mkdir/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_mkdir);
+uucore::bin!(uu_mkdir);
diff --git a/src/uu/mkdir/src/mkdir.rs b/src/uu/mkdir/src/mkdir.rs
index 9ff816dcb..7c8d4e413 100644
--- a/src/uu/mkdir/src/mkdir.rs
+++ b/src/uu/mkdir/src/mkdir.rs
@@ -10,19 +10,21 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::OsValues;
-use clap::{crate_version, App, Arg, ArgMatches};
-use std::fs;
-use std::path::Path;
-use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
+use clap::{crate_version, Arg, ArgMatches, Command, OsValues};
+use std::path::{Path, PathBuf};
+#[cfg(not(windows))]
+use uucore::error::FromIo;
+use uucore::error::{UResult, USimpleError};
 #[cfg(not(windows))]
 use uucore::mode;
-use uucore::InvalidEncodingHandling;
+use uucore::{display::Quotable, fs::dir_strip_dot_for_creation};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static DEFAULT_PERM: u32 = 0o755;
 
 static ABOUT: &str = "Create the given DIRECTORY(ies) if they do not exist";
+const USAGE: &str = "{} [OPTION]... [USER]";
+
 mod options {
     pub const MODE: &str = "mode";
     pub const PARENTS: &str = "parents";
@@ -30,9 +32,6 @@ mod options {
     pub const DIRS: &str = "dirs";
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [USER]", uucore::execution_phrase())
-}
 fn get_long_usage() -> String {
     String::from("Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.")
 }
@@ -79,7 +78,7 @@ fn strip_minus_from_mode(args: &mut Vec<String>) -> bool {
     mode::strip_minus_from_mode(args)
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let mut args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
@@ -88,17 +87,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     // Before we can parse 'args' with clap (and previously getopts),
     // a possible MODE prefix '-' needs to be removed (e.g. "chmod -x FILE").
     let mode_had_minus_prefix = strip_minus_from_mode(&mut args);
-
-    let usage = usage();
     let after_help = get_long_usage();
 
     // Linux-specific options, not implemented
     // opts.optflag("Z", "context", "set SELinux security context" +
     // " of each created directory to CTX"),
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let dirs = matches.values_of_os(options::DIRS).unwrap_or_default();
     let verbose = matches.is_present(options::VERBOSE);
@@ -110,35 +104,37 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::MODE)
-                .short("m")
+            Arg::new(options::MODE)
+                .short('m')
                 .long(options::MODE)
                 .help("set file mode (not implemented on windows)")
                 .default_value("755"),
         )
         .arg(
-            Arg::with_name(options::PARENTS)
-                .short("p")
+            Arg::new(options::PARENTS)
+                .short('p')
                 .long(options::PARENTS)
-                .alias("parent")
                 .help("make parent directories as needed"),
         )
         .arg(
-            Arg::with_name(options::VERBOSE)
-                .short("v")
+            Arg::new(options::VERBOSE)
+                .short('v')
                 .long(options::VERBOSE)
                 .help("print a message for each printed directory"),
         )
         .arg(
-            Arg::with_name(options::DIRS)
-                .multiple(true)
+            Arg::new(options::DIRS)
+                .multiple_occurrences(true)
                 .takes_value(true)
-                .min_values(1),
+                .min_values(1)
+                .allow_invalid_utf8(true),
         )
 }
 
@@ -147,29 +143,22 @@ pub fn uu_app() -> App<'static, 'static> {
  */
 fn exec(dirs: OsValues, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
     for dir in dirs {
-        let path = Path::new(dir);
-        show_if_err!(mkdir(path, recursive, mode, verbose));
+        // Special case to match GNU's behavior:
+        // mkdir -p foo/. should work and just create foo/
+        // std::fs::create_dir("foo/."); fails in pure Rust
+        let path = if recursive {
+            dir_strip_dot_for_creation(&PathBuf::from(dir))
+        } else {
+            // Normal case
+            PathBuf::from(dir)
+        };
+        show_if_err!(mkdir(path.as_path(), recursive, mode, verbose));
     }
     Ok(())
 }
 
 fn mkdir(path: &Path, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
-    let create_dir = if recursive {
-        fs::create_dir_all
-    } else {
-        fs::create_dir
-    };
-
-    create_dir(path).map_err_context(|| format!("cannot create directory {}", path.quote()))?;
-
-    if verbose {
-        println!(
-            "{}: created directory {}",
-            uucore::util_name(),
-            path.quote()
-        );
-    }
-
+    create_dir(path, recursive, verbose)?;
     chmod(path, mode)
 }
 
@@ -189,3 +178,38 @@ fn chmod(_path: &Path, _mode: u32) -> UResult<()> {
     // chmod on Windows only sets the readonly flag, which isn't even honored on directories
     Ok(())
 }
+
+fn create_dir(path: &Path, recursive: bool, verbose: bool) -> UResult<()> {
+    if path.exists() && !recursive {
+        return Err(USimpleError::new(
+            1,
+            format!("{}: File exists", path.display()),
+        ));
+    }
+    if path == Path::new("") {
+        return Ok(());
+    }
+
+    if recursive {
+        match path.parent() {
+            Some(p) => create_dir(p, recursive, verbose)?,
+            None => {
+                USimpleError::new(1, "failed to create whole tree");
+            }
+        }
+    }
+    match std::fs::create_dir(path) {
+        Ok(()) => {
+            if verbose {
+                println!(
+                    "{}: created directory {}",
+                    uucore::util_name(),
+                    path.quote()
+                );
+            }
+            Ok(())
+        }
+        Err(_) if path.is_dir() => Ok(()),
+        Err(e) => Err(e.into()),
+    }
+}
diff --git a/src/uu/mkfifo/Cargo.toml b/src/uu/mkfifo/Cargo.toml
index acf38f6bc..1c16043ae 100644
--- a/src/uu/mkfifo/Cargo.toml
+++ b/src/uu/mkfifo/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_mkfifo"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mkfifo ~ (uutils) create FIFOs (named pipes)"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/mkfifo"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mkfifo"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/mkfifo.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "mkfifo"
diff --git a/src/uu/mkfifo/LICENSE b/src/uu/mkfifo/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/mkfifo/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/mkfifo/src/main.rs b/src/uu/mkfifo/src/main.rs
index 3ad5a3bed..b803f2c6f 100644
--- a/src/uu/mkfifo/src/main.rs
+++ b/src/uu/mkfifo/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_mkfifo);
+uucore::bin!(uu_mkfifo);
diff --git a/src/uu/mkfifo/src/mkfifo.rs b/src/uu/mkfifo/src/mkfifo.rs
index 66c3f7bb6..756fd75cf 100644
--- a/src/uu/mkfifo/src/mkfifo.rs
+++ b/src/uu/mkfifo/src/mkfifo.rs
@@ -8,13 +8,15 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use libc::mkfifo;
 use std::ffi::CString;
+use uucore::error::{UResult, USimpleError};
+use uucore::format_usage;
 use uucore::{display::Quotable, InvalidEncodingHandling};
 
 static NAME: &str = "mkfifo";
-static USAGE: &str = "mkfifo [OPTION]... NAME...";
+static USAGE: &str = "{} [OPTION]... NAME...";
 static SUMMARY: &str = "Create a FIFO with the given name.";
 
 mod options {
@@ -24,7 +26,8 @@ mod options {
     pub static FIFO: &str = "fifo";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
@@ -32,64 +35,63 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     let matches = uu_app().get_matches_from(args);
 
     if matches.is_present(options::CONTEXT) {
-        crash!(1, "--context is not implemented");
+        return Err(USimpleError::new(1, "--context is not implemented"));
     }
     if matches.is_present(options::SE_LINUX_SECURITY_CONTEXT) {
-        crash!(1, "-Z is not implemented");
+        return Err(USimpleError::new(1, "-Z is not implemented"));
     }
 
     let mode = match matches.value_of(options::MODE) {
         Some(m) => match usize::from_str_radix(m, 8) {
             Ok(m) => m,
-            Err(e) => {
-                show_error!("invalid mode: {}", e);
-                return 1;
-            }
+            Err(e) => return Err(USimpleError::new(1, format!("invalid mode: {}", e))),
         },
         None => 0o666,
     };
 
     let fifos: Vec<String> = match matches.values_of(options::FIFO) {
         Some(v) => v.clone().map(|s| s.to_owned()).collect(),
-        None => crash!(1, "missing operand"),
+        None => return Err(USimpleError::new(1, "missing operand")),
     };
 
-    let mut exit_code = 0;
     for f in fifos {
         let err = unsafe {
             let name = CString::new(f.as_bytes()).unwrap();
             mkfifo(name.as_ptr(), mode as libc::mode_t)
         };
         if err == -1 {
-            show_error!("cannot create fifo {}: File exists", f.quote());
-            exit_code = 1;
+            show!(USimpleError::new(
+                1,
+                format!("cannot create fifo {}: File exists", f.quote())
+            ));
         }
     }
 
-    exit_code
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::MODE)
-                .short("m")
+            Arg::new(options::MODE)
+                .short('m')
                 .long(options::MODE)
                 .help("file permissions for the fifo")
                 .default_value("0666")
                 .value_name("0666"),
         )
         .arg(
-            Arg::with_name(options::SE_LINUX_SECURITY_CONTEXT)
-                .short(options::SE_LINUX_SECURITY_CONTEXT)
+            Arg::new(options::SE_LINUX_SECURITY_CONTEXT)
+                .short('Z')
                 .help("set the SELinux security context to default type"),
         )
         .arg(
-            Arg::with_name(options::CONTEXT)
+            Arg::new(options::CONTEXT)
                 .long(options::CONTEXT)
                 .value_name("CTX")
                 .help(
@@ -97,5 +99,9 @@ pub fn uu_app() -> App<'static, 'static> {
                     or SMACK security context to CTX",
                 ),
         )
-        .arg(Arg::with_name(options::FIFO).hidden(true).multiple(true))
+        .arg(
+            Arg::new(options::FIFO)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
 }
diff --git a/src/uu/mknod/Cargo.toml b/src/uu/mknod/Cargo.toml
index 046e4b8d0..68de0443b 100644
--- a/src/uu/mknod/Cargo.toml
+++ b/src/uu/mknod/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_mknod"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mknod ~ (uutils) create special file NAME of TYPE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/mknod"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mknod"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -16,10 +16,9 @@ name = "uu_mknod"
 path = "src/mknod.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "^0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["mode"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "^0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["mode"] }
 
 [[bin]]
 name = "mknod"
diff --git a/src/uu/mknod/LICENSE b/src/uu/mknod/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/mknod/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/mknod/src/main.rs b/src/uu/mknod/src/main.rs
index b65a20cd4..cfb4f1982 100644
--- a/src/uu/mknod/src/main.rs
+++ b/src/uu/mknod/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_mknod);
+uucore::bin!(uu_mknod);
diff --git a/src/uu/mknod/src/mknod.rs b/src/uu/mknod/src/mknod.rs
index dd529c3ba..0e7c4be45 100644
--- a/src/uu/mknod/src/mknod.rs
+++ b/src/uu/mknod/src/mknod.rs
@@ -7,20 +7,18 @@
 
 // spell-checker:ignore (ToDO) parsemode makedev sysmacros perror IFBLK IFCHR IFIFO
 
-#[macro_use]
-extern crate uucore;
-
 use std::ffi::CString;
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use libc::{dev_t, mode_t};
 use libc::{S_IFBLK, S_IFCHR, S_IFIFO, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR};
 
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{set_exit_code, UResult, USimpleError, UUsageError};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "Create the special file NAME of the given TYPE.";
-static USAGE: &str = "mknod [OPTION]... NAME TYPE [MAJOR MINOR]";
+static USAGE: &str = "{} [OPTION]... NAME TYPE [MAJOR MINOR]";
 static LONG_HELP: &str = "Mandatory arguments to long options are mandatory for short options too.
 -m, --mode=MODE    set file permission bits to MODE, not a=rw - umask
 --help     display this help and exit
@@ -81,8 +79,8 @@ fn _mknod(file_name: &str, mode: mode_t, dev: dev_t) -> i32 {
     }
 }
 
-#[allow(clippy::cognitive_complexity)]
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
@@ -92,13 +90,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     let matches = uu_app().get_matches_from(args);
 
-    let mode = match get_mode(&matches) {
-        Ok(mode) => mode,
-        Err(err) => {
-            show_error!("{}", err);
-            return 1;
-        }
-    };
+    let mode = get_mode(&matches).map_err(|e| USimpleError::new(1, e))?;
 
     let file_name = matches.value_of("name").expect("Missing argument 'NAME'");
 
@@ -113,31 +105,29 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     if ch == 'p' {
         if matches.is_present("major") || matches.is_present("minor") {
-            eprintln!("Fifos do not have major and minor device numbers.");
-            eprintln!(
-                "Try '{} --help' for more information.",
-                uucore::execution_phrase()
-            );
-            1
+            Err(UUsageError::new(
+                1,
+                "Fifos do not have major and minor device numbers.",
+            ))
         } else {
-            _mknod(file_name, S_IFIFO | mode, 0)
+            let exit_code = _mknod(file_name, S_IFIFO | mode, 0);
+            set_exit_code(exit_code);
+            Ok(())
         }
     } else {
         match (matches.value_of("major"), matches.value_of("minor")) {
             (None, None) | (_, None) | (None, _) => {
-                eprintln!("Special files require major and minor device numbers.");
-                eprintln!(
-                    "Try '{} --help' for more information.",
-                    uucore::execution_phrase()
-                );
-                1
+                return Err(UUsageError::new(
+                    1,
+                    "Special files require major and minor device numbers.",
+                ));
             }
             (Some(major), Some(minor)) => {
                 let major = major.parse::<u64>().expect("validated by clap");
                 let minor = minor.parse::<u64>().expect("validated by clap");
 
                 let dev = makedev(major, minor);
-                if ch == 'b' {
+                let exit_code = if ch == 'b' {
                     // block special file
                     _mknod(file_name, S_IFBLK | mode, dev)
                 } else if ch == 'c' || ch == 'u' {
@@ -145,34 +135,37 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                     _mknod(file_name, S_IFCHR | mode, dev)
                 } else {
                     unreachable!("{} was validated to be only b, c or u", ch);
-                }
+                };
+                set_exit_code(exit_code);
+                Ok(())
             }
         }
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .after_help(LONG_HELP)
         .about(ABOUT)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name("mode")
-                .short("m")
+            Arg::new("mode")
+                .short('m')
                 .long("mode")
                 .value_name("MODE")
                 .help("set file permission bits to MODE, not a=rw - umask"),
         )
         .arg(
-            Arg::with_name("name")
+            Arg::new("name")
                 .value_name("NAME")
                 .help("name of the new file")
                 .required(true)
                 .index(1),
         )
         .arg(
-            Arg::with_name("type")
+            Arg::new("type")
                 .value_name("TYPE")
                 .help("type of the new file (b, c, u or p)")
                 .required(true)
@@ -180,14 +173,14 @@ pub fn uu_app() -> App<'static, 'static> {
                 .index(2),
         )
         .arg(
-            Arg::with_name("major")
+            Arg::new("major")
                 .value_name("MAJOR")
                 .help("major file type")
                 .validator(valid_u64)
                 .index(3),
         )
         .arg(
-            Arg::with_name("minor")
+            Arg::new("minor")
                 .value_name("MINOR")
                 .help("minor file type")
                 .validator(valid_u64)
@@ -210,7 +203,7 @@ fn get_mode(matches: &ArgMatches) -> Result<mode_t, String> {
     }
 }
 
-fn valid_type(tpe: String) -> Result<(), String> {
+fn valid_type(tpe: &str) -> Result<(), String> {
     // Only check the first character, to allow mnemonic usage like
     // 'mknod /dev/rst0 character 18 0'.
     tpe.chars()
@@ -225,6 +218,6 @@ fn valid_type(tpe: String) -> Result<(), String> {
         })
 }
 
-fn valid_u64(num: String) -> Result<(), String> {
-    num.parse::<u64>().map(|_| ()).map_err(|_| num)
+fn valid_u64(num: &str) -> Result<(), String> {
+    num.parse::<u64>().map(|_| ()).map_err(|_| num.into())
 }
diff --git a/src/uu/mktemp/Cargo.toml b/src/uu/mktemp/Cargo.toml
index de896dba7..19af4f20e 100644
--- a/src/uu/mktemp/Cargo.toml
+++ b/src/uu/mktemp/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_mktemp"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mktemp ~ (uutils) create and display a temporary file or directory from TEMPLATE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/mktemp"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mktemp"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,10 @@ edition = "2018"
 path = "src/mktemp.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-rand = "0.5"
-tempfile = "3.1"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+rand = "0.8"
+tempfile = "3"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "mktemp"
diff --git a/src/uu/mktemp/LICENSE b/src/uu/mktemp/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/mktemp/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/mktemp/src/main.rs b/src/uu/mktemp/src/main.rs
index 020284655..4fb826ebb 100644
--- a/src/uu/mktemp/src/main.rs
+++ b/src/uu/mktemp/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_mktemp);
+uucore::bin!(uu_mktemp);
diff --git a/src/uu/mktemp/src/mktemp.rs b/src/uu/mktemp/src/mktemp.rs
index 4318f0ad6..54283b9af 100644
--- a/src/uu/mktemp/src/mktemp.rs
+++ b/src/uu/mktemp/src/mktemp.rs
@@ -8,20 +8,22 @@
 
 // spell-checker:ignore (paths) GPGHome
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use uucore::display::{println_verbatim, Quotable};
 use uucore::error::{FromIo, UError, UResult};
+use uucore::format_usage;
 
 use std::env;
 use std::error::Error;
 use std::fmt::Display;
 use std::iter;
-use std::path::{is_separator, PathBuf};
+use std::path::{is_separator, Path, PathBuf};
 
 use rand::Rng;
 use tempfile::Builder;
 
 static ABOUT: &str = "create a temporary file or directory.";
+const USAGE: &str = "{} [OPTION]... [TEMPLATE]";
 
 static DEFAULT_TEMPLATE: &str = "tmp.XXXXXXXXXX";
 
@@ -34,10 +36,6 @@ static OPT_T: &str = "t";
 
 static ARG_TEMPLATE: &str = "template";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [TEMPLATE]", uucore::execution_phrase())
-}
-
 #[derive(Debug)]
 enum MkTempError {
     PersistError(PathBuf),
@@ -74,11 +72,9 @@ impl Display for MkTempError {
     }
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     let template = matches.value_of(ARG_TEMPLATE).unwrap();
     let tmpdir = matches.value_of(OPT_TMPDIR).unwrap_or_default();
@@ -118,13 +114,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 
     if matches.is_present(OPT_T) {
-        tmpdir = env::temp_dir()
+        tmpdir = env::temp_dir();
     }
 
     let res = if dry_run {
         dry_exec(tmpdir, prefix, rand, suffix)
     } else {
-        exec(tmpdir, prefix, rand, suffix, make_dir)
+        exec(&tmpdir, prefix, rand, suffix, make_dir)
     };
 
     if suppress_file_err {
@@ -135,30 +131,32 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_DIRECTORY)
-                .short("d")
+            Arg::new(OPT_DIRECTORY)
+                .short('d')
                 .long(OPT_DIRECTORY)
                 .help("Make a directory instead of a file"),
         )
         .arg(
-            Arg::with_name(OPT_DRY_RUN)
-                .short("u")
+            Arg::new(OPT_DRY_RUN)
+                .short('u')
                 .long(OPT_DRY_RUN)
                 .help("do not create anything; merely print a name (unsafe)"),
         )
         .arg(
-            Arg::with_name(OPT_QUIET)
-                .short("q")
+            Arg::new(OPT_QUIET)
+                .short('q')
                 .long("quiet")
                 .help("Fail silently if an error occurs."),
         )
         .arg(
-            Arg::with_name(OPT_SUFFIX)
+            Arg::new(OPT_SUFFIX)
                 .long(OPT_SUFFIX)
                 .help(
                     "append SUFFIX to TEMPLATE; SUFFIX must not contain a path separator. \
@@ -167,8 +165,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .value_name("SUFFIX"),
         )
         .arg(
-            Arg::with_name(OPT_TMPDIR)
-                .short("p")
+            Arg::new(OPT_TMPDIR)
+                .short('p')
                 .long(OPT_TMPDIR)
                 .help(
                     "interpret TEMPLATE relative to DIR; if DIR is not specified, use \
@@ -178,13 +176,13 @@ pub fn uu_app() -> App<'static, 'static> {
                 )
                 .value_name("DIR"),
         )
-        .arg(Arg::with_name(OPT_T).short(OPT_T).help(
+        .arg(Arg::new(OPT_T).short('t').help(
             "Generate a template (using the supplied prefix and TMPDIR (TMP on windows) if set) \
              to create a filename template [deprecated]",
         ))
         .arg(
-            Arg::with_name(ARG_TEMPLATE)
-                .multiple(false)
+            Arg::new(ARG_TEMPLATE)
+                .multiple_occurrences(false)
                 .takes_value(true)
                 .max_values(1)
                 .default_value(DEFAULT_TEMPLATE),
@@ -248,7 +246,7 @@ pub fn dry_exec(mut tmpdir: PathBuf, prefix: &str, rand: usize, suffix: &str) ->
     println_verbatim(tmpdir).map_err_context(|| "failed to print directory name".to_owned())
 }
 
-fn exec(dir: PathBuf, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> UResult<()> {
+fn exec(dir: &Path, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> UResult<()> {
     let context = || {
         format!(
             "failed to create file via template '{}{}{}'",
diff --git a/src/uu/more/Cargo.toml b/src/uu/more/Cargo.toml
index 0111376f9..230276938 100644
--- a/src/uu/more/Cargo.toml
+++ b/src/uu/more/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_more"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "more ~ (uutils) input perusal filter"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/more"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/more"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,25 +15,16 @@ edition = "2018"
 path = "src/more.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 uucore = { version = ">=0.0.7", package = "uucore", path = "../../uucore" }
-uucore_procs = { version=">=0.0.7", package = "uucore_procs", path = "../../uucore_procs" }
 crossterm = ">=0.19"
 atty = "0.2"
 unicode-width = "0.1.7"
-unicode-segmentation = "1.7.1"
-
-[target.'cfg(target_os = "redox")'.dependencies]
-redox_termios = "0.1"
-redox_syscall = "0.2"
+unicode-segmentation = "1.9.0"
 
 [target.'cfg(all(unix, not(target_os = "fuchsia")))'.dependencies]
-nix = "0.19"
+nix = "0.23.1"
 
 [[bin]]
 name = "more"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/more/LICENSE b/src/uu/more/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/more/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/more/src/main.rs b/src/uu/more/src/main.rs
index 15fbf51f9..d0c3c3e23 100644
--- a/src/uu/more/src/main.rs
+++ b/src/uu/more/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_more);
+uucore::bin!(uu_more);
diff --git a/src/uu/more/src/more.rs b/src/uu/more/src/more.rs
index d424d5a77..ab94bd435 100644
--- a/src/uu/more/src/more.rs
+++ b/src/uu/more/src/more.rs
@@ -7,9 +7,6 @@
 
 // spell-checker:ignore (methods) isnt
 
-#[macro_use]
-extern crate uucore;
-
 use std::{
     fs::File,
     io::{stdin, stdout, BufReader, Read, Stdout, Write},
@@ -20,7 +17,7 @@ use std::{
 #[cfg(all(unix, not(target_os = "fuchsia")))]
 extern crate nix;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use crossterm::{
     event::{self, Event, KeyCode, KeyEvent, KeyModifiers},
     execute, queue,
@@ -31,6 +28,7 @@ use crossterm::{
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 use uucore::display::Quotable;
+use uucore::error::{UResult, USimpleError, UUsageError};
 
 const BELL: &str = "\x07";
 
@@ -51,7 +49,8 @@ pub mod options {
 
 const MULTI_FILE_TOP_PROMPT: &str = "::::::::::::::\n{}\n::::::::::::::\n";
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().get_matches_from(args);
 
     let mut buff = String::new();
@@ -65,92 +64,97 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             let file = Path::new(file);
             if file.is_dir() {
                 terminal::disable_raw_mode().unwrap();
-                show_usage_error!("{} is a directory.", file.quote());
-                return 1;
+                return Err(UUsageError::new(
+                    1,
+                    format!("{} is a directory.", file.quote()),
+                ));
             }
             if !file.exists() {
                 terminal::disable_raw_mode().unwrap();
-                show_error!("cannot open {}: No such file or directory", file.quote());
-                return 1;
+                return Err(USimpleError::new(
+                    1,
+                    format!("cannot open {}: No such file or directory", file.quote()),
+                ));
             }
             if length > 1 {
                 buff.push_str(&MULTI_FILE_TOP_PROMPT.replace("{}", file.to_str().unwrap()));
             }
             let mut reader = BufReader::new(File::open(file).unwrap());
             reader.read_to_string(&mut buff).unwrap();
-            more(&buff, &mut stdout, next_file.copied(), silent);
+            more(&buff, &mut stdout, next_file.copied(), silent)?;
             buff.clear();
         }
         reset_term(&mut stdout);
     } else if atty::isnt(atty::Stream::Stdin) {
         stdin().read_to_string(&mut buff).unwrap();
         let mut stdout = setup_term();
-        more(&buff, &mut stdout, None, silent);
+        more(&buff, &mut stdout, None, silent)?;
         reset_term(&mut stdout);
     } else {
-        show_usage_error!("bad usage");
+        return Err(UUsageError::new(1, "bad usage"));
     }
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .about("A file perusal filter for CRT viewing.")
         .version(crate_version!())
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::SILENT)
-                .short("d")
+            Arg::new(options::SILENT)
+                .short('d')
                 .long(options::SILENT)
                 .help("Display help instead of ringing bell"),
         )
         // The commented arguments below are unimplemented:
         /*
         .arg(
-            Arg::with_name(options::LOGICAL)
-                .short("f")
+            Arg::new(options::LOGICAL)
+                .short('f')
                 .long(options::LOGICAL)
                 .help("Count logical rather than screen lines"),
         )
         .arg(
-            Arg::with_name(options::NO_PAUSE)
-                .short("l")
+            Arg::new(options::NO_PAUSE)
+                .short('l')
                 .long(options::NO_PAUSE)
                 .help("Suppress pause after form feed"),
         )
         .arg(
-            Arg::with_name(options::PRINT_OVER)
-                .short("c")
+            Arg::new(options::PRINT_OVER)
+                .short('c')
                 .long(options::PRINT_OVER)
                 .help("Do not scroll, display text and clean line ends"),
         )
         .arg(
-            Arg::with_name(options::CLEAN_PRINT)
-                .short("p")
+            Arg::new(options::CLEAN_PRINT)
+                .short('p')
                 .long(options::CLEAN_PRINT)
                 .help("Do not scroll, clean screen and display text"),
         )
         .arg(
-            Arg::with_name(options::SQUEEZE)
-                .short("s")
+            Arg::new(options::SQUEEZE)
+                .short('s')
                 .long(options::SQUEEZE)
                 .help("Squeeze multiple blank lines into one"),
         )
         .arg(
-            Arg::with_name(options::PLAIN)
-                .short("u")
+            Arg::new(options::PLAIN)
+                .short('u')
                 .long(options::PLAIN)
                 .help("Suppress underlining and bold"),
         )
         .arg(
-            Arg::with_name(options::LINES)
-                .short("n")
+            Arg::new(options::LINES)
+                .short('n')
                 .long(options::LINES)
                 .value_name("number")
                 .takes_value(true)
                 .help("The number of lines per screen full"),
         )
         .arg(
-            Arg::with_name(options::NUMBER)
+            Arg::new(options::NUMBER)
                 .allow_hyphen_values(true)
                 .long(options::NUMBER)
                 .required(false)
@@ -158,8 +162,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .help("Same as --lines"),
         )
         .arg(
-            Arg::with_name(options::FROM_LINE)
-                .short("F")
+            Arg::new(options::FROM_LINE)
+                .short('F')
                 .allow_hyphen_values(true)
                 .required(false)
                 .takes_value(true)
@@ -167,8 +171,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .help("Display file beginning from line number"),
         )
         .arg(
-            Arg::with_name(options::PATTERN)
-                .short("P")
+            Arg::new(options::PATTERN)
+                .short('P')
                 .allow_hyphen_values(true)
                 .required(false)
                 .takes_value(true)
@@ -176,9 +180,9 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         */
         .arg(
-            Arg::with_name(options::FILES)
+            Arg::new(options::FILES)
                 .required(false)
-                .multiple(true)
+                .multiple_occurrences(true)
                 .help("Path to the files to be read"),
         )
 }
@@ -210,14 +214,14 @@ fn reset_term(stdout: &mut std::io::Stdout) {
 #[inline(always)]
 fn reset_term(_: &mut usize) {}
 
-fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool) {
+fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool) -> UResult<()> {
     let (cols, rows) = terminal::size().unwrap();
     let lines = break_buff(buff, usize::from(cols));
 
     let mut pager = Pager::new(rows, lines, next_file, silent);
     pager.draw(stdout, None);
     if pager.should_close() {
-        return;
+        return Ok(());
     }
 
     loop {
@@ -244,7 +248,7 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
                     modifiers: KeyModifiers::NONE,
                 }) => {
                     if pager.should_close() {
-                        return;
+                        return Ok(());
                     } else {
                         pager.page_down();
                     }
@@ -255,6 +259,22 @@ fn more(buff: &str, stdout: &mut Stdout, next_file: Option<&str>, silent: bool)
                 }) => {
                     pager.page_up();
                 }
+                Event::Key(KeyEvent {
+                    code: KeyCode::Char('j'),
+                    modifiers: KeyModifiers::NONE,
+                }) => {
+                    if pager.should_close() {
+                        return Ok(());
+                    } else {
+                        pager.next_line();
+                    }
+                }
+                Event::Key(KeyEvent {
+                    code: KeyCode::Char('k'),
+                    modifiers: KeyModifiers::NONE,
+                }) => {
+                    pager.prev_line();
+                }
                 Event::Resize(col, row) => {
                     pager.page_resize(col, row);
                 }
@@ -301,6 +321,17 @@ impl<'a> Pager<'a> {
     }
 
     fn page_down(&mut self) {
+        // If the next page down position __after redraw__ is greater than the total line count,
+        // the upper mark must not grow past top of the screen at the end of the open file.
+        if self
+            .upper_mark
+            .saturating_add(self.content_rows as usize * 2)
+            .ge(&self.line_count)
+        {
+            self.upper_mark = self.line_count - self.content_rows as usize;
+            return;
+        }
+
         self.upper_mark = self.upper_mark.saturating_add(self.content_rows.into());
     }
 
@@ -308,6 +339,14 @@ impl<'a> Pager<'a> {
         self.upper_mark = self.upper_mark.saturating_sub(self.content_rows.into());
     }
 
+    fn next_line(&mut self) {
+        self.upper_mark = self.upper_mark.saturating_add(1);
+    }
+
+    fn prev_line(&mut self) {
+        self.upper_mark = self.upper_mark.saturating_sub(1);
+    }
+
     // TODO: Deal with column size changes.
     fn page_resize(&mut self, _: u16, row: u16) {
         self.content_rows = row.saturating_sub(1);
diff --git a/src/uu/mv/Cargo.toml b/src/uu/mv/Cargo.toml
index 6dd129af9..861d96c7f 100644
--- a/src/uu/mv/Cargo.toml
+++ b/src/uu/mv/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_mv"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "mv ~ (uutils) move (rename) SOURCE to DESTINATION"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/mv"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mv"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,10 @@ edition = "2018"
 path = "src/mv.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 fs_extra = "1.1.0"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "mv"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/mv/LICENSE b/src/uu/mv/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/mv/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/mv/src/error.rs b/src/uu/mv/src/error.rs
new file mode 100644
index 000000000..6a605626e
--- /dev/null
+++ b/src/uu/mv/src/error.rs
@@ -0,0 +1,43 @@
+// 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 std::error::Error;
+use std::fmt::{Display, Formatter, Result};
+
+use uucore::error::UError;
+
+#[derive(Debug)]
+pub enum MvError {
+    NoSuchFile(String),
+    SameFile(String, String),
+    SelfSubdirectory(String),
+    DirectoryToNonDirectory(String),
+    NonDirectoryToDirectory(String, String),
+    NotADirectory(String),
+}
+
+impl Error for MvError {}
+impl UError for MvError {}
+impl Display for MvError {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        match self {
+            MvError::NoSuchFile(s) => write!(f, "cannot stat {}: No such file or directory", s),
+            MvError::SameFile(s, t) => write!(f, "{} and {} are the same file", s, t),
+            MvError::SelfSubdirectory(s) => write!(
+                f,
+                "cannot move '{s}' to a subdirectory of itself, '{s}/{s}'",
+                s = s
+            ),
+            MvError::DirectoryToNonDirectory(t) => {
+                write!(f, "cannot overwrite directory {} with non-directory", t)
+            }
+            MvError::NonDirectoryToDirectory(s, t) => write!(
+                f,
+                "cannot overwrite non-directory {} with directory {}",
+                t, s
+            ),
+            MvError::NotADirectory(t) => write!(f, "target {} is not a directory", t),
+        }
+    }
+}
diff --git a/src/uu/mv/src/main.rs b/src/uu/mv/src/main.rs
index 49f7956e8..d0abc28c1 100644
--- a/src/uu/mv/src/main.rs
+++ b/src/uu/mv/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_mv);
+uucore::bin!(uu_mv);
diff --git a/src/uu/mv/src/mv.rs b/src/uu/mv/src/mv.rs
index 9d23f86de..60cff5dfb 100644
--- a/src/uu/mv/src/mv.rs
+++ b/src/uu/mv/src/mv.rs
@@ -8,11 +8,14 @@
 
 // spell-checker:ignore (ToDO) sourcepath targetpath
 
+mod error;
+
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use std::env;
+use std::ffi::OsString;
 use std::fs;
 use std::io::{self, stdin};
 #[cfg(unix)]
@@ -22,17 +25,22 @@ use std::os::windows;
 use std::path::{Path, PathBuf};
 use uucore::backup_control::{self, BackupMode};
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UError, UResult, USimpleError, UUsageError};
+use uucore::format_usage;
 
 use fs_extra::dir::{move_dir, CopyOptions as DirCopyOptions};
 
+use crate::error::MvError;
+
 pub struct Behavior {
     overwrite: OverwriteMode,
     backup: BackupMode,
     suffix: String,
     update: bool,
-    target_dir: Option<String>,
+    target_dir: Option<OsString>,
     no_target_dir: bool,
     verbose: bool,
+    strip_slashes: bool,
 }
 
 #[derive(Clone, Eq, PartialEq)]
@@ -44,6 +52,10 @@ pub enum OverwriteMode {
 
 static ABOUT: &str = "Move SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.";
 static LONG_HELP: &str = "";
+const USAGE: &str = "\
+    {} [OPTION]... [-T] SOURCE DEST
+    {} [OPTION]... SOURCE... DIRECTORY
+    {} [OPTION]... -t DIRECTORY SOURCE...";
 
 static OPT_FORCE: &str = "force";
 static OPT_INTERACTIVE: &str = "interactive";
@@ -56,44 +68,30 @@ static OPT_VERBOSE: &str = "verbose";
 
 static ARG_FILES: &str = "files";
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [-T] SOURCE DEST
-{0} [OPTION]... SOURCE... DIRECTORY
-{0} [OPTION]... -t DIRECTORY SOURCE...",
-        uucore::execution_phrase()
-    )
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app()
         .after_help(&*format!(
             "{}\n{}",
             LONG_HELP,
             backup_control::BACKUP_CONTROL_LONG_HELP
         ))
-        .usage(&usage[..])
         .get_matches_from(args);
 
-    let files: Vec<String> = matches
-        .values_of(ARG_FILES)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
+    let files: Vec<OsString> = matches
+        .values_of_os(ARG_FILES)
+        .unwrap_or_default()
+        .map(|v| v.to_os_string())
+        .collect();
 
     let overwrite_mode = determine_overwrite_mode(&matches);
-    let backup_mode = match backup_control::determine_backup_mode(&matches) {
-        Err(e) => {
-            show!(e);
-            return 1;
-        }
-        Ok(mode) => mode,
-    };
+    let backup_mode = backup_control::determine_backup_mode(&matches)?;
 
     if overwrite_mode == OverwriteMode::NoClobber && backup_mode != BackupMode::NoBackup {
-        show_usage_error!("options --backup and --no-clobber are mutually exclusive");
-        return 1;
+        return Err(UUsageError::new(
+            1,
+            "options --backup and --no-clobber are mutually exclusive",
+        ));
     }
 
     let backup_suffix = backup_control::determine_backup_suffix(&matches);
@@ -103,32 +101,23 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         backup: backup_mode,
         suffix: backup_suffix,
         update: matches.is_present(OPT_UPDATE),
-        target_dir: matches.value_of(OPT_TARGET_DIRECTORY).map(String::from),
+        target_dir: matches
+            .value_of_os(OPT_TARGET_DIRECTORY)
+            .map(OsString::from),
         no_target_dir: matches.is_present(OPT_NO_TARGET_DIRECTORY),
         verbose: matches.is_present(OPT_VERBOSE),
+        strip_slashes: matches.is_present(OPT_STRIP_TRAILING_SLASHES),
     };
 
-    let paths: Vec<PathBuf> = {
-        fn strip_slashes(p: &Path) -> &Path {
-            p.components().as_path()
-        }
-        let to_owned = |p: &Path| p.to_owned();
-        let paths = files.iter().map(Path::new);
-
-        if matches.is_present(OPT_STRIP_TRAILING_SLASHES) {
-            paths.map(strip_slashes).map(to_owned).collect()
-        } else {
-            paths.map(to_owned).collect()
-        }
-    };
-
-    exec(&paths[..], behavior)
+    exec(&files[..], &behavior)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
     .arg(
         backup_control::arguments::backup()
     )
@@ -136,24 +125,24 @@ pub fn uu_app() -> App<'static, 'static> {
         backup_control::arguments::backup_no_args()
     )
     .arg(
-            Arg::with_name(OPT_FORCE)
-            .short("f")
+            Arg::new(OPT_FORCE)
+            .short('f')
             .long(OPT_FORCE)
             .help("do not prompt before overwriting")
     )
     .arg(
-            Arg::with_name(OPT_INTERACTIVE)
-            .short("i")
+            Arg::new(OPT_INTERACTIVE)
+            .short('i')
             .long(OPT_INTERACTIVE)
             .help("prompt before override")
     )
     .arg(
-            Arg::with_name(OPT_NO_CLOBBER).short("n")
+            Arg::new(OPT_NO_CLOBBER).short('n')
             .long(OPT_NO_CLOBBER)
             .help("do not overwrite an existing file")
     )
     .arg(
-            Arg::with_name(OPT_STRIP_TRAILING_SLASHES)
+            Arg::new(OPT_STRIP_TRAILING_SLASHES)
             .long(OPT_STRIP_TRAILING_SLASHES)
             .help("remove any trailing slashes from each SOURCE argument")
     )
@@ -161,37 +150,39 @@ pub fn uu_app() -> App<'static, 'static> {
         backup_control::arguments::suffix()
     )
     .arg(
-        Arg::with_name(OPT_TARGET_DIRECTORY)
-        .short("t")
+        Arg::new(OPT_TARGET_DIRECTORY)
+        .short('t')
         .long(OPT_TARGET_DIRECTORY)
         .help("move all SOURCE arguments into DIRECTORY")
         .takes_value(true)
         .value_name("DIRECTORY")
         .conflicts_with(OPT_NO_TARGET_DIRECTORY)
+        .allow_invalid_utf8(true)
     )
     .arg(
-            Arg::with_name(OPT_NO_TARGET_DIRECTORY)
-            .short("T")
+            Arg::new(OPT_NO_TARGET_DIRECTORY)
+            .short('T')
             .long(OPT_NO_TARGET_DIRECTORY).
             help("treat DEST as a normal file")
     )
     .arg(
-            Arg::with_name(OPT_UPDATE)
-            .short("u")
+            Arg::new(OPT_UPDATE)
+            .short('u')
             .long(OPT_UPDATE)
             .help("move only when the SOURCE file is newer than the destination file or when the destination file is missing")
     )
     .arg(
-            Arg::with_name(OPT_VERBOSE)
-            .short("v")
+            Arg::new(OPT_VERBOSE)
+            .short('v')
             .long(OPT_VERBOSE).help("explain what is being done")
     )
     .arg(
-        Arg::with_name(ARG_FILES)
-            .multiple(true)
+        Arg::new(ARG_FILES)
+            .multiple_occurrences(true)
             .takes_value(true)
             .min_values(2)
             .required(true)
+            .allow_invalid_utf8(true)
         )
 }
 
@@ -210,117 +201,107 @@ fn determine_overwrite_mode(matches: &ArgMatches) -> OverwriteMode {
     }
 }
 
-fn exec(files: &[PathBuf], b: Behavior) -> i32 {
+fn exec(files: &[OsString], b: &Behavior) -> UResult<()> {
+    let paths: Vec<PathBuf> = {
+        let paths = files.iter().map(Path::new);
+
+        // Strip slashes from path, if strip opt present
+        if b.strip_slashes {
+            paths
+                .map(|p| p.components().as_path().to_owned())
+                .collect::<Vec<PathBuf>>()
+        } else {
+            paths.map(|p| p.to_owned()).collect::<Vec<PathBuf>>()
+        }
+    };
+
     if let Some(ref name) = b.target_dir {
-        return move_files_into_dir(files, &PathBuf::from(name), &b);
+        return move_files_into_dir(&paths, &PathBuf::from(name), b);
     }
-    match files.len() {
+    match paths.len() {
         /* case 0/1 are not possible thanks to clap */
         2 => {
-            let source = &files[0];
-            let target = &files[1];
+            let source = &paths[0];
+            let target = &paths[1];
             // Here we use the `symlink_metadata()` method instead of `exists()`,
             // since it handles dangling symlinks correctly. The method gives an
             // `Ok()` results unless the source does not exist, or the user
             // lacks permission to access metadata.
             if source.symlink_metadata().is_err() {
-                show_error!("cannot stat {}: No such file or directory", source.quote());
-                return 1;
+                return Err(MvError::NoSuchFile(source.quote().to_string()).into());
+            }
+
+            // GNU semantics are: if the source and target are the same, no move occurs and we print an error
+            if source.eq(target) {
+                // Done to match GNU semantics for the dot file
+                if source.eq(Path::new(".")) || source.ends_with("/.") || source.is_file() {
+                    return Err(MvError::SameFile(
+                        source.quote().to_string(),
+                        target.quote().to_string(),
+                    )
+                    .into());
+                } else {
+                    return Err(MvError::SelfSubdirectory(source.display().to_string()).into());
+                }
             }
 
             if target.is_dir() {
                 if b.no_target_dir {
                     if !source.is_dir() {
-                        show_error!(
-                            "cannot overwrite directory {} with non-directory",
-                            target.quote()
-                        );
-                        return 1;
+                        Err(MvError::DirectoryToNonDirectory(target.quote().to_string()).into())
+                    } else {
+                        rename(source, target, b).map_err_context(|| {
+                            format!("cannot move {} to {}", source.quote(), target.quote())
+                        })
                     }
-
-                    return match rename(source, target, &b) {
-                        Err(e) => {
-                            show_error!(
-                                "cannot move {} to {}: {}",
-                                source.quote(),
-                                target.quote(),
-                                e.to_string()
-                            );
-                            1
-                        }
-                        _ => 0,
-                    };
+                } else {
+                    move_files_into_dir(&[source.clone()], target, b)
                 }
-
-                return move_files_into_dir(&[source.clone()], target, &b);
             } else if target.exists() && source.is_dir() {
-                show_error!(
-                    "cannot overwrite non-directory {} with directory {}",
-                    target.quote(),
-                    source.quote()
-                );
-                return 1;
-            }
-
-            if let Err(e) = rename(source, target, &b) {
-                show_error!("{}", e);
-                return 1;
+                Err(MvError::NonDirectoryToDirectory(
+                    source.quote().to_string(),
+                    target.quote().to_string(),
+                )
+                .into())
+            } else {
+                rename(source, target, b).map_err(|e| USimpleError::new(1, format!("{}", e)))
             }
         }
         _ => {
             if b.no_target_dir {
-                show_error!(
-                    "mv: extra operand {}\n\
-                     Try '{} --help' for more information.",
-                    files[2].quote(),
-                    uucore::execution_phrase()
-                );
-                return 1;
+                return Err(UUsageError::new(
+                    1,
+                    format!("mv: extra operand {}", files[2].quote()),
+                ));
             }
-            let target_dir = files.last().unwrap();
-            move_files_into_dir(&files[..files.len() - 1], target_dir, &b);
+            let target_dir = paths.last().unwrap();
+            move_files_into_dir(&paths[..paths.len() - 1], target_dir, b)
         }
     }
-    0
 }
 
-fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> i32 {
+fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UResult<()> {
     if !target_dir.is_dir() {
-        show_error!("target {} is not a directory", target_dir.quote());
-        return 1;
+        return Err(MvError::NotADirectory(target_dir.quote().to_string()).into());
     }
 
-    let mut all_successful = true;
     for sourcepath in files.iter() {
         let targetpath = match sourcepath.file_name() {
             Some(name) => target_dir.join(name),
             None => {
-                show_error!(
-                    "cannot stat {}: No such file or directory",
-                    sourcepath.quote()
-                );
-
-                all_successful = false;
+                show!(MvError::NoSuchFile(sourcepath.quote().to_string()));
                 continue;
             }
         };
-
-        if let Err(e) = rename(sourcepath, &targetpath, b) {
-            show_error!(
-                "cannot move {} to {}: {}",
+        show_if_err!(
+            rename(sourcepath, &targetpath, b).map_err_context(|| format!(
+                "cannot move {} to {}",
                 sourcepath.quote(),
-                targetpath.quote(),
-                e.to_string()
-            );
-            all_successful = false;
-        }
-    }
-
-    if all_successful {
-        0
-    } else {
-        1
+                targetpath.quote()
+            ))
+        );
     }
+    Ok(())
 }
 
 fn rename(from: &Path, to: &Path, b: &Behavior) -> io::Result<()> {
@@ -353,7 +334,7 @@ fn rename(from: &Path, to: &Path, b: &Behavior) -> io::Result<()> {
         // normalize behavior between *nix and windows
         if from.is_dir() {
             if is_empty_dir(to) {
-                fs::remove_dir(to)?
+                fs::remove_dir(to)?;
             } else {
                 return Err(io::Error::new(io::ErrorKind::Other, "Directory not empty"));
             }
diff --git a/src/uu/nice/Cargo.toml b/src/uu/nice/Cargo.toml
index ac719a768..37d88e8a8 100644
--- a/src/uu/nice/Cargo.toml
+++ b/src/uu/nice/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_nice"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nice ~ (uutils) run PROGRAM with modified scheduling priority"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/nice"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nice"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,10 @@ edition = "2018"
 path = "src/nice.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-nix = "0.20"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+nix = "0.23.1"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "nice"
diff --git a/src/uu/nice/LICENSE b/src/uu/nice/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/nice/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/nice/src/main.rs b/src/uu/nice/src/main.rs
index 039f40d9d..7e7f23792 100644
--- a/src/uu/nice/src/main.rs
+++ b/src/uu/nice/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_nice);
+uucore::bin!(uu_nice);
diff --git a/src/uu/nice/src/nice.rs b/src/uu/nice/src/nice.rs
index fbc2be0e5..b75dd979e 100644
--- a/src/uu/nice/src/nice.rs
+++ b/src/uu/nice/src/nice.rs
@@ -15,61 +15,61 @@ use std::ffi::CString;
 use std::io::Error;
 use std::ptr;
 
-use clap::{crate_version, App, AppSettings, Arg};
+use clap::{crate_version, Arg, Command};
+use uucore::{
+    error::{set_exit_code, UResult, USimpleError, UUsageError},
+    format_usage,
+};
 
 pub mod options {
     pub static ADJUSTMENT: &str = "adjustment";
     pub static COMMAND: &str = "COMMAND";
 }
 
-fn usage() -> String {
-    format!(
-        "
-  {0} [OPTIONS] [COMMAND [ARGS]]
+const ABOUT: &str = "\
+    Run COMMAND with an adjusted niceness, which affects process scheduling. \
+    With no COMMAND, print the current niceness.  Niceness values range from at \
+    least -20 (most favorable to the process) to 19 (least favorable to the \
+    process).";
+const USAGE: &str = "{} [OPTIONS] [COMMAND [ARGS]]";
 
-Run COMMAND with an adjusted niceness, which affects process scheduling.
-With no COMMAND, print the current niceness.  Niceness values range from at
-least -20 (most favorable to the process) to 19 (least favorable to the
-process).",
-        uucore::execution_phrase()
-    )
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let mut niceness = unsafe {
         nix::errno::Errno::clear();
         libc::getpriority(PRIO_PROCESS, 0)
     };
     if Error::last_os_error().raw_os_error().unwrap() != 0 {
-        show_error!("getpriority: {}", Error::last_os_error());
-        return 125;
+        return Err(USimpleError::new(
+            125,
+            format!("getpriority: {}", Error::last_os_error()),
+        ));
     }
 
     let adjustment = match matches.value_of(options::ADJUSTMENT) {
         Some(nstr) => {
             if !matches.is_present(options::COMMAND) {
-                show_error!(
-                    "A command must be given with an adjustment.\nTry '{} --help' for more information.",
-                    uucore::execution_phrase()
-                );
-                return 125;
+                return Err(UUsageError::new(
+                    125,
+                    "A command must be given with an adjustment.",
+                ));
             }
             match nstr.parse() {
                 Ok(num) => num,
                 Err(e) => {
-                    show_error!("\"{}\" is not a valid number: {}", nstr, e);
-                    return 125;
+                    return Err(USimpleError::new(
+                        125,
+                        format!("\"{}\" is not a valid number: {}", nstr, e),
+                    ))
                 }
             }
         }
         None => {
             if !matches.is_present(options::COMMAND) {
                 println!("{}", niceness);
-                return 0;
+                return Ok(());
             }
             10_i32
         }
@@ -93,24 +93,29 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     }
 
     show_error!("execvp: {}", Error::last_os_error());
-    if Error::last_os_error().raw_os_error().unwrap() as c_int == libc::ENOENT {
+    let exit_code = if Error::last_os_error().raw_os_error().unwrap() as c_int == libc::ENOENT {
         127
     } else {
         126
-    }
+    };
+    set_exit_code(exit_code);
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
-        .setting(AppSettings::TrailingVarArg)
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .trailing_var_arg(true)
+        .infer_long_args(true)
         .version(crate_version!())
         .arg(
-            Arg::with_name(options::ADJUSTMENT)
-                .short("n")
+            Arg::new(options::ADJUSTMENT)
+                .short('n')
                 .long(options::ADJUSTMENT)
                 .help("add N to the niceness (default is 10)")
                 .takes_value(true)
                 .allow_hyphen_values(true),
         )
-        .arg(Arg::with_name(options::COMMAND).multiple(true))
+        .arg(Arg::new(options::COMMAND).multiple_occurrences(true))
 }
diff --git a/src/uu/nl/Cargo.toml b/src/uu/nl/Cargo.toml
index 781f6502d..8901cf34a 100644
--- a/src/uu/nl/Cargo.toml
+++ b/src/uu/nl/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_nl"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nl ~ (uutils) display input with added line numbers"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/nl"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nl"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,19 +15,10 @@ edition = "2018"
 path = "src/nl.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-aho-corasick = "0.7.3"
-libc = "0.2.42"
-memchr = "2.2.0"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 regex = "1.0.1"
-regex-syntax = "0.6.7"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "nl"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/nl/LICENSE b/src/uu/nl/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/nl/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/nl/src/main.rs b/src/uu/nl/src/main.rs
index 072fad504..3b66630fa 100644
--- a/src/uu/nl/src/main.rs
+++ b/src/uu/nl/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_nl);
+uucore::bin!(uu_nl);
diff --git a/src/uu/nl/src/nl.rs b/src/uu/nl/src/nl.rs
index 600ebace0..28cf3fb4d 100644
--- a/src/uu/nl/src/nl.rs
+++ b/src/uu/nl/src/nl.rs
@@ -8,21 +8,18 @@
 
 // spell-checker:ignore (ToDO) corasick memchr
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::File;
 use std::io::{stdin, BufRead, BufReader, Read};
 use std::iter::repeat;
 use std::path::Path;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 mod helper;
 
 static NAME: &str = "nl";
-static USAGE: &str = "nl [OPTION]... [FILE]...";
-// A regular expression matching everything.
+static USAGE: &str = "{} [OPTION]... [FILE]...";
 
 // Settings store options used by nl to produce its output.
 pub struct Settings {
@@ -69,6 +66,7 @@ enum NumberFormat {
 }
 
 pub mod options {
+    pub const HELP: &str = "help";
     pub const FILE: &str = "file";
     pub const BODY_NUMBERING: &str = "body-numbering";
     pub const SECTION_DELIMITER: &str = "section-delimiter";
@@ -83,7 +81,8 @@ pub mod options {
     pub const NUMBER_WIDTH: &str = "number-width";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -109,11 +108,10 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     // program if some options could not successfully be parsed.
     let parse_errors = helper::parse_options(&mut settings, &matches);
     if !parse_errors.is_empty() {
-        show_error!("Invalid arguments supplied.");
-        for message in &parse_errors {
-            println!("{}", message);
-        }
-        return 1;
+        return Err(USimpleError::new(
+            1,
+            format!("Invalid arguments supplied.\n{}", parse_errors.join("\n")),
+        ));
     }
 
     let mut read_stdin = false;
@@ -130,96 +128,106 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             continue;
         }
         let path = Path::new(file);
-        let reader = File::open(path).unwrap();
+        let reader = File::open(path).map_err_context(|| file.to_string())?;
         let mut buffer = BufReader::new(reader);
-        nl(&mut buffer, &settings);
+        nl(&mut buffer, &settings)?;
     }
 
     if read_stdin {
         let mut buffer = BufReader::new(stdin());
-        nl(&mut buffer, &settings);
+        nl(&mut buffer, &settings)?;
     }
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(USAGE)
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BODY_NUMBERING)
-                .short("b")
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information."),
+        )
+        .arg(
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
+        .arg(
+            Arg::new(options::BODY_NUMBERING)
+                .short('b')
                 .long(options::BODY_NUMBERING)
                 .help("use STYLE for numbering body lines")
                 .value_name("SYNTAX"),
         )
         .arg(
-            Arg::with_name(options::SECTION_DELIMITER)
-                .short("d")
+            Arg::new(options::SECTION_DELIMITER)
+                .short('d')
                 .long(options::SECTION_DELIMITER)
                 .help("use CC for separating logical pages")
                 .value_name("CC"),
         )
         .arg(
-            Arg::with_name(options::FOOTER_NUMBERING)
-                .short("f")
+            Arg::new(options::FOOTER_NUMBERING)
+                .short('f')
                 .long(options::FOOTER_NUMBERING)
                 .help("use STYLE for numbering footer lines")
                 .value_name("STYLE"),
         )
         .arg(
-            Arg::with_name(options::HEADER_NUMBERING)
-                .short("h")
+            Arg::new(options::HEADER_NUMBERING)
+                .short('h')
                 .long(options::HEADER_NUMBERING)
                 .help("use STYLE for numbering header lines")
                 .value_name("STYLE"),
         )
         .arg(
-            Arg::with_name(options::LINE_INCREMENT)
-                .short("i")
+            Arg::new(options::LINE_INCREMENT)
+                .short('i')
                 .long(options::LINE_INCREMENT)
                 .help("line number increment at each line")
                 .value_name("NUMBER"),
         )
         .arg(
-            Arg::with_name(options::JOIN_BLANK_LINES)
-                .short("l")
+            Arg::new(options::JOIN_BLANK_LINES)
+                .short('l')
                 .long(options::JOIN_BLANK_LINES)
                 .help("group of NUMBER empty lines counted as one")
                 .value_name("NUMBER"),
         )
         .arg(
-            Arg::with_name(options::NUMBER_FORMAT)
-                .short("n")
+            Arg::new(options::NUMBER_FORMAT)
+                .short('n')
                 .long(options::NUMBER_FORMAT)
                 .help("insert line numbers according to FORMAT")
                 .value_name("FORMAT"),
         )
         .arg(
-            Arg::with_name(options::NO_RENUMBER)
-                .short("p")
+            Arg::new(options::NO_RENUMBER)
+                .short('p')
                 .long(options::NO_RENUMBER)
                 .help("do not reset line numbers at logical pages"),
         )
         .arg(
-            Arg::with_name(options::NUMBER_SEPARATOR)
-                .short("s")
+            Arg::new(options::NUMBER_SEPARATOR)
+                .short('s')
                 .long(options::NUMBER_SEPARATOR)
                 .help("add STRING after (possible) line number")
                 .value_name("STRING"),
         )
         .arg(
-            Arg::with_name(options::STARTING_LINE_NUMBER)
-                .short("v")
+            Arg::new(options::STARTING_LINE_NUMBER)
+                .short('v')
                 .long(options::STARTING_LINE_NUMBER)
                 .help("first line number on each logical page")
                 .value_name("NUMBER"),
         )
         .arg(
-            Arg::with_name(options::NUMBER_WIDTH)
-                .short("w")
+            Arg::new(options::NUMBER_WIDTH)
+                .short('w')
                 .long(options::NUMBER_WIDTH)
                 .help("use NUMBER columns for line numbers")
                 .value_name("NUMBER"),
@@ -227,7 +235,7 @@ pub fn uu_app() -> App<'static, 'static> {
 }
 
 // nl implements the main functionality for an individual buffer.
-fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) {
+fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
     let regexp: regex::Regex = regex::Regex::new(r".?").unwrap();
     let mut line_no = settings.starting_line_number;
     // The current line number's width as a string. Using to_string is inefficient
@@ -248,7 +256,8 @@ fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) {
         _ => &regexp,
     };
     let mut line_filter: fn(&str, &regex::Regex) -> bool = pass_regex;
-    for mut l in reader.lines().map(|r| r.unwrap()) {
+    for l in reader.lines() {
+        let mut l = l.map_err_context(|| "could not read line".to_string())?;
         // Sanitize the string. We want to print the newline ourselves.
         if l.ends_with('\n') {
             l.pop();
@@ -372,6 +381,7 @@ fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) {
             line_no_width += 1;
         }
     }
+    Ok(())
 }
 
 fn pass_regex(line: &str, re: &regex::Regex) -> bool {
diff --git a/src/uu/nohup/Cargo.toml b/src/uu/nohup/Cargo.toml
index c2f3c329e..fd2b5e82d 100644
--- a/src/uu/nohup/Cargo.toml
+++ b/src/uu/nohup/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_nohup"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nohup ~ (uutils) run COMMAND, ignoring hangup signals"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/nohup"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nohup"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,10 @@ edition = "2018"
 path = "src/nohup.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
 atty = "0.2"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "nohup"
diff --git a/src/uu/nohup/LICENSE b/src/uu/nohup/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/nohup/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/nohup/src/main.rs b/src/uu/nohup/src/main.rs
index 2007711f6..0d197bbf2 100644
--- a/src/uu/nohup/src/main.rs
+++ b/src/uu/nohup/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_nohup);
+uucore::bin!(uu_nohup);
diff --git a/src/uu/nohup/src/nohup.rs b/src/uu/nohup/src/nohup.rs
index d83170ae8..cfafb6b5b 100644
--- a/src/uu/nohup/src/nohup.rs
+++ b/src/uu/nohup/src/nohup.rs
@@ -10,17 +10,19 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, AppSettings, Arg};
+use clap::{crate_version, Arg, Command};
 use libc::{c_char, dup2, execvp, signal};
 use libc::{SIGHUP, SIG_IGN};
 use std::env;
 use std::ffi::CString;
+use std::fmt::{Display, Formatter};
 use std::fs::{File, OpenOptions};
 use std::io::Error;
 use std::os::unix::prelude::*;
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{set_exit_code, UError, UResult};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "Run COMMAND ignoring hangup signals.";
 static LONG_HELP: &str = "
@@ -29,6 +31,9 @@ If standard output is terminal, it'll be appended to nohup.out instead,
 or $HOME/nohup.out, if nohup.out open failed.
 If standard error is terminal, it'll be redirected to stdout.
 ";
+const USAGE: &str = "\
+    {} COMMAND [ARG]...
+    {} FLAG";
 static NOHUP_OUT: &str = "nohup.out";
 // exit codes that match the GNU implementation
 static EXIT_CANCELED: i32 = 125;
@@ -40,20 +45,59 @@ mod options {
     pub const CMD: &str = "cmd";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[derive(Debug)]
+enum NohupError {
+    CannotDetach,
+    CannotReplace(&'static str, std::io::Error),
+    OpenFailed(i32, std::io::Error),
+    OpenFailed2(i32, std::io::Error, String, std::io::Error),
+}
+
+impl std::error::Error for NohupError {}
+
+impl UError for NohupError {
+    fn code(&self) -> i32 {
+        match self {
+            Self::OpenFailed(code, _) | Self::OpenFailed2(code, _, _, _) => *code,
+            _ => 2,
+        }
+    }
+}
+
+impl Display for NohupError {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Self::CannotDetach => write!(f, "Cannot detach from console"),
+            Self::CannotReplace(s, e) => write!(f, "Cannot replace {}: {}", s, e),
+            Self::OpenFailed(_, e) => {
+                write!(f, "failed to open {}: {}", NOHUP_OUT.quote(), e)
+            }
+            NohupError::OpenFailed2(_, e1, s, e2) => write!(
+                f,
+                "failed to open {}: {}\nfailed to open {}: {}",
+                NOHUP_OUT.quote(),
+                e1,
+                s.quote(),
+                e2
+            ),
+        }
+    }
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
-    replace_fds();
+    replace_fds()?;
 
     unsafe { signal(SIGHUP, SIG_IGN) };
 
     if unsafe { !_vprocmgr_detach_from_console(0).is_null() } {
-        crash!(2, "Cannot detach from console")
+        return Err(NohupError::CannotDetach.into());
     };
 
     let cstrs: Vec<CString> = matches
@@ -66,51 +110,53 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     let ret = unsafe { execvp(args[0], args.as_mut_ptr()) };
     match ret {
-        libc::ENOENT => EXIT_ENOENT,
-        _ => EXIT_CANNOT_INVOKE,
+        libc::ENOENT => set_exit_code(EXIT_ENOENT),
+        _ => set_exit_code(EXIT_CANNOT_INVOKE),
     }
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
+        .override_usage(format_usage(USAGE))
         .arg(
-            Arg::with_name(options::CMD)
-                .hidden(true)
+            Arg::new(options::CMD)
+                .hide(true)
                 .required(true)
-                .multiple(true),
+                .multiple_occurrences(true),
         )
-        .setting(AppSettings::TrailingVarArg)
+        .trailing_var_arg(true)
+        .infer_long_args(true)
 }
 
-fn replace_fds() {
+fn replace_fds() -> UResult<()> {
     if atty::is(atty::Stream::Stdin) {
-        let new_stdin = match File::open(Path::new("/dev/null")) {
-            Ok(t) => t,
-            Err(e) => crash!(2, "Cannot replace STDIN: {}", e),
-        };
+        let new_stdin = File::open(Path::new("/dev/null"))
+            .map_err(|e| NohupError::CannotReplace("STDIN", e))?;
         if unsafe { dup2(new_stdin.as_raw_fd(), 0) } != 0 {
-            crash!(2, "Cannot replace STDIN: {}", Error::last_os_error())
+            return Err(NohupError::CannotReplace("STDIN", Error::last_os_error()).into());
         }
     }
 
     if atty::is(atty::Stream::Stdout) {
-        let new_stdout = find_stdout();
+        let new_stdout = find_stdout()?;
         let fd = new_stdout.as_raw_fd();
 
         if unsafe { dup2(fd, 1) } != 1 {
-            crash!(2, "Cannot replace STDOUT: {}", Error::last_os_error())
+            return Err(NohupError::CannotReplace("STDOUT", Error::last_os_error()).into());
         }
     }
 
     if atty::is(atty::Stream::Stderr) && unsafe { dup2(1, 2) } != 2 {
-        crash!(2, "Cannot replace STDERR: {}", Error::last_os_error())
+        return Err(NohupError::CannotReplace("STDERR", Error::last_os_error()).into());
     }
+    Ok(())
 }
 
-fn find_stdout() -> File {
+fn find_stdout() -> UResult<File> {
     let internal_failure_code = match std::env::var("POSIXLY_CORRECT") {
         Ok(_) => POSIX_NOHUP_FAILURE,
         Err(_) => EXIT_CANCELED,
@@ -127,14 +173,11 @@ fn find_stdout() -> File {
                 "ignoring input and appending output to {}",
                 NOHUP_OUT.quote()
             );
-            t
+            Ok(t)
         }
         Err(e1) => {
             let home = match env::var("HOME") {
-                Err(_) => {
-                    show_error!("failed to open {}: {}", NOHUP_OUT.quote(), e1);
-                    exit!(internal_failure_code)
-                }
+                Err(_) => return Err(NohupError::OpenFailed(internal_failure_code, e1).into()),
                 Ok(h) => h,
             };
             let mut homeout = PathBuf::from(home);
@@ -151,25 +194,20 @@ fn find_stdout() -> File {
                         "ignoring input and appending output to {}",
                         homeout_str.quote()
                     );
-                    t
-                }
-                Err(e2) => {
-                    show_error!("failed to open {}: {}", NOHUP_OUT.quote(), e1);
-                    show_error!("failed to open {}: {}", homeout_str.quote(), e2);
-                    exit!(internal_failure_code)
+                    Ok(t)
                 }
+                Err(e2) => Err(NohupError::OpenFailed2(
+                    internal_failure_code,
+                    e1,
+                    homeout_str.to_string(),
+                    e2,
+                )
+                .into()),
             }
         }
     }
 }
 
-fn usage() -> String {
-    format!(
-        "{0} COMMAND [ARG]...\n    {0} FLAG",
-        uucore::execution_phrase()
-    )
-}
-
 #[cfg(target_vendor = "apple")]
 extern "C" {
     fn _vprocmgr_detach_from_console(flags: u32) -> *const libc::c_int;
diff --git a/src/uu/nproc/Cargo.toml b/src/uu/nproc/Cargo.toml
index 3c44062bd..c44c9883d 100644
--- a/src/uu/nproc/Cargo.toml
+++ b/src/uu/nproc/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_nproc"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "nproc ~ (uutils) display the number of processing units available"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/nproc"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nproc"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,10 @@ edition = "2018"
 path = "src/nproc.rs"
 
 [dependencies]
-libc = "0.2.42"
+libc = "0.2.121"
 num_cpus = "1.10"
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "nproc"
diff --git a/src/uu/nproc/LICENSE b/src/uu/nproc/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/nproc/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/nproc/src/main.rs b/src/uu/nproc/src/main.rs
index 356c2101f..71853dd03 100644
--- a/src/uu/nproc/src/main.rs
+++ b/src/uu/nproc/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_nproc);
+uucore::bin!(uu_nproc);
diff --git a/src/uu/nproc/src/nproc.rs b/src/uu/nproc/src/nproc.rs
index 16b8d8c3a..87fe9a4e7 100644
--- a/src/uu/nproc/src/nproc.rs
+++ b/src/uu/nproc/src/nproc.rs
@@ -7,11 +7,11 @@
 
 // spell-checker:ignore (ToDO) NPROCESSORS nprocs numstr threadstr sysconf
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::env;
+use uucore::display::Quotable;
+use uucore::error::{UResult, USimpleError};
+use uucore::format_usage;
 
 #[cfg(target_os = "linux")]
 pub const _SC_NPROCESSORS_CONF: libc::c_int = 83;
@@ -25,63 +25,90 @@ pub const _SC_NPROCESSORS_CONF: libc::c_int = 1001;
 static OPT_ALL: &str = "all";
 static OPT_IGNORE: &str = "ignore";
 
-static ABOUT: &str = "Print the number of cores available to the current process.";
+static ABOUT: &str = r#"Print the number of cores available to the current process.
+If the OMP_NUM_THREADS or OMP_THREAD_LIMIT environment variables are set, then
+they will determine the minimum and maximum returned value respectively."#;
+const USAGE: &str = "{} [OPTIONS]...";
 
-fn usage() -> String {
-    format!("{0} [OPTIONS]...", uucore::execution_phrase())
-}
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
-
-    let mut ignore = match matches.value_of(OPT_IGNORE) {
-        Some(numstr) => match numstr.parse() {
+    let ignore = match matches.value_of(OPT_IGNORE) {
+        Some(numstr) => match numstr.trim().parse() {
             Ok(num) => num,
             Err(e) => {
-                show_error!("\"{}\" is not a valid number: {}", numstr, e);
-                return 1;
+                return Err(USimpleError::new(
+                    1,
+                    format!("{} is not a valid number: {}", numstr.quote(), e),
+                ));
             }
         },
         None => 0,
     };
 
-    if !matches.is_present(OPT_ALL) {
-        // OMP_NUM_THREADS doesn't have an impact on --all
-        ignore += match env::var("OMP_NUM_THREADS") {
-            Ok(threadstr) => threadstr.parse().unwrap_or(0),
-            Err(_) => 0,
-        };
-    }
+    let limit = match env::var("OMP_THREAD_LIMIT") {
+        // Uses the OpenMP variable to limit the number of threads
+        // If the parsing fails, returns the max size (so, no impact)
+        // If OMP_THREAD_LIMIT=0, rejects the value
+        Ok(threadstr) => match threadstr.parse() {
+            Ok(0) | Err(_) => usize::MAX,
+            Ok(n) => n,
+        },
+        // the variable 'OMP_THREAD_LIMIT' doesn't exist
+        // fallback to the max
+        Err(_) => usize::MAX,
+    };
 
     let mut cores = if matches.is_present(OPT_ALL) {
         num_cpus_all()
     } else {
-        num_cpus::get()
+        // OMP_NUM_THREADS doesn't have an impact on --all
+        match env::var("OMP_NUM_THREADS") {
+            // Uses the OpenMP variable to force the number of threads
+            // If the parsing fails, returns the number of CPU
+            Ok(threadstr) => {
+                // In some cases, OMP_NUM_THREADS can be "x,y,z"
+                // In this case, only take the first one (like GNU)
+                // If OMP_NUM_THREADS=0, rejects the value
+                let thread: Vec<&str> = threadstr.split_terminator(',').collect();
+                match &thread[..] {
+                    [] => num_cpus::get(),
+                    [s, ..] => match s.parse() {
+                        Ok(0) | Err(_) => num_cpus::get(),
+                        Ok(n) => n,
+                    },
+                }
+            }
+            // the variable 'OMP_NUM_THREADS' doesn't exist
+            // fallback to the regular CPU detection
+            Err(_) => num_cpus::get(),
+        }
     };
 
+    cores = std::cmp::min(limit, cores);
     if cores <= ignore {
         cores = 1;
     } else {
         cores -= ignore;
     }
     println!("{}", cores);
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_ALL)
-                .short("")
+            Arg::new(OPT_ALL)
                 .long(OPT_ALL)
                 .help("print the number of cores available to the system"),
         )
         .arg(
-            Arg::with_name(OPT_IGNORE)
-                .short("")
+            Arg::new(OPT_IGNORE)
                 .long(OPT_IGNORE)
                 .takes_value(true)
                 .help("ignore up to N cores"),
diff --git a/src/uu/numfmt/Cargo.toml b/src/uu/numfmt/Cargo.toml
index 60bfb3b14..216503aae 100644
--- a/src/uu/numfmt/Cargo.toml
+++ b/src/uu/numfmt/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_numfmt"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "numfmt ~ (uutils) reformat NUMBER"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/numfmt"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/numfmt"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/numfmt.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "numfmt"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/numfmt/LICENSE b/src/uu/numfmt/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/numfmt/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/numfmt/src/errors.rs b/src/uu/numfmt/src/errors.rs
new file mode 100644
index 000000000..af7de9caa
--- /dev/null
+++ b/src/uu/numfmt/src/errors.rs
@@ -0,0 +1,39 @@
+//  * 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 std::{
+    error::Error,
+    fmt::{Debug, Display},
+};
+use uucore::error::UError;
+
+#[derive(Debug)]
+pub enum NumfmtError {
+    IoError(String),
+    IllegalArgument(String),
+    FormattingError(String),
+}
+
+impl UError for NumfmtError {
+    fn code(&self) -> i32 {
+        match self {
+            NumfmtError::IoError(_) => 1,
+            NumfmtError::IllegalArgument(_) => 1,
+            NumfmtError::FormattingError(_) => 2,
+        }
+    }
+}
+
+impl Error for NumfmtError {}
+
+impl Display for NumfmtError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            NumfmtError::IoError(s)
+            | NumfmtError::IllegalArgument(s)
+            | NumfmtError::FormattingError(s) => write!(f, "{}", s),
+        }
+    }
+}
diff --git a/src/uu/numfmt/src/format.rs b/src/uu/numfmt/src/format.rs
index bdee83e12..f66e1ac0a 100644
--- a/src/uu/numfmt/src/format.rs
+++ b/src/uu/numfmt/src/format.rs
@@ -45,13 +45,13 @@ impl<'a> Iterator for WhitespaceSplitter<'a> {
         let (prefix, field) = haystack.split_at(
             haystack
                 .find(|c: char| !c.is_whitespace())
-                .unwrap_or_else(|| haystack.len()),
+                .unwrap_or(haystack.len()),
         );
 
         let (field, rest) = field.split_at(
             field
                 .find(|c: char| c.is_whitespace())
-                .unwrap_or_else(|| field.len()),
+                .unwrap_or(field.len()),
         );
 
         self.s = if !rest.is_empty() { Some(rest) } else { None };
@@ -220,16 +220,32 @@ fn format_string(
     options: &NumfmtOptions,
     implicit_padding: Option<isize>,
 ) -> Result<String> {
+    // strip the (optional) suffix before applying any transformation
+    let source_without_suffix = match &options.suffix {
+        Some(suffix) => source.strip_suffix(suffix).unwrap_or(source),
+        None => source,
+    };
+
     let number = transform_to(
-        transform_from(source, &options.transform.from)?,
+        transform_from(source_without_suffix, &options.transform.from)?,
         &options.transform.to,
         options.round,
     )?;
 
+    // bring back the suffix before applying padding
+    let number_with_suffix = match &options.suffix {
+        Some(suffix) => format!("{}{}", number, suffix),
+        None => number,
+    };
+
     Ok(match implicit_padding.unwrap_or(options.padding) {
-        0 => number,
-        p if p > 0 => format!("{:>padding$}", number, padding = p as usize),
-        p => format!("{:<padding$}", number, padding = p.abs() as usize),
+        0 => number_with_suffix,
+        p if p > 0 => format!("{:>padding$}", number_with_suffix, padding = p as usize),
+        p => format!(
+            "{:<padding$}",
+            number_with_suffix,
+            padding = p.abs() as usize
+        ),
     })
 }
 
@@ -269,7 +285,7 @@ fn format_and_print_whitespace(s: &str, options: &NumfmtOptions) -> Result<()> {
                 print!(" ");
                 &prefix[1..]
             } else {
-                &prefix
+                prefix
             };
 
             let implicit_padding = if !empty_prefix && options.padding == 0 {
diff --git a/src/uu/numfmt/src/main.rs b/src/uu/numfmt/src/main.rs
index f4d991727..753e56252 100644
--- a/src/uu/numfmt/src/main.rs
+++ b/src/uu/numfmt/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_numfmt);
+uucore::bin!(uu_numfmt);
diff --git a/src/uu/numfmt/src/numfmt.rs b/src/uu/numfmt/src/numfmt.rs
index da2fa8130..1b3ab3950 100644
--- a/src/uu/numfmt/src/numfmt.rs
+++ b/src/uu/numfmt/src/numfmt.rs
@@ -7,17 +7,18 @@
 
 // spell-checker:ignore N'th M'th
 
-#[macro_use]
-extern crate uucore;
-
+use crate::errors::*;
 use crate::format::format_and_print;
 use crate::options::*;
 use crate::units::{Result, Unit};
-use clap::{crate_version, App, AppSettings, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use std::io::{BufRead, Write};
 use uucore::display::Quotable;
+use uucore::error::UResult;
+use uucore::format_usage;
 use uucore::ranges::Range;
 
+pub mod errors;
 pub mod format;
 pub mod options;
 mod units;
@@ -50,33 +51,37 @@ FIELDS supports cut(1) style field ranges:
   -    all fields
 Multiple fields/ranges can be separated with commas
 ";
+const USAGE: &str = "{} [OPTION]... [NUMBER]...";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [NUMBER]...", uucore::execution_phrase())
-}
-
-fn handle_args<'a>(args: impl Iterator<Item = &'a str>, options: NumfmtOptions) -> Result<()> {
+fn handle_args<'a>(args: impl Iterator<Item = &'a str>, options: &NumfmtOptions) -> UResult<()> {
     for l in args {
-        format_and_print(l, &options)?;
+        match format_and_print(l, options) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(NumfmtError::FormattingError(e.to_string())),
+        }?;
     }
 
     Ok(())
 }
 
-fn handle_stdin(options: NumfmtOptions) -> Result<()> {
-    let stdin = std::io::stdin();
-    let locked_stdin = stdin.lock();
-
-    let mut lines = locked_stdin.lines();
-    for l in lines.by_ref().take(options.header) {
-        l.map(|s| println!("{}", s)).map_err(|e| e.to_string())?;
+fn handle_buffer<R>(input: R, options: &NumfmtOptions) -> UResult<()>
+where
+    R: BufRead,
+{
+    let mut lines = input.lines();
+    for (idx, line) in lines.by_ref().enumerate() {
+        match line {
+            Ok(l) if idx < options.header => {
+                println!("{}", l);
+                Ok(())
+            }
+            Ok(l) => match format_and_print(&l, options) {
+                Ok(_) => Ok(()),
+                Err(e) => Err(NumfmtError::FormattingError(e.to_string())),
+            },
+            Err(e) => Err(NumfmtError::IoError(e.to_string())),
+        }?;
     }
-
-    for l in lines {
-        l.map_err(|e| e.to_string())
-            .and_then(|l| format_and_print(&l, &options))?;
-    }
-
     Ok(())
 }
 
@@ -144,6 +149,8 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         _ => unreachable!("Should be restricted by clap"),
     };
 
+    let suffix = args.value_of(options::SUFFIX).map(|s| s.to_owned());
+
     Ok(NumfmtOptions {
         transform,
         padding,
@@ -151,66 +158,72 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         fields,
         delimiter,
         round,
+        suffix,
     })
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let options = parse_options(&matches).map_err(NumfmtError::IllegalArgument)?;
 
-    let result =
-        parse_options(&matches).and_then(|options| match matches.values_of(options::NUMBER) {
-            Some(values) => handle_args(values, options),
-            None => handle_stdin(options),
-        });
+    let result = match matches.values_of(options::NUMBER) {
+        Some(values) => handle_args(values, &options),
+        None => {
+            let stdin = std::io::stdin();
+            let mut locked_stdin = stdin.lock();
+            handle_buffer(&mut locked_stdin, &options)
+        }
+    };
 
     match result {
         Err(e) => {
             std::io::stdout().flush().expect("error flushing stdout");
-            show_error!("{}", e);
-            1
+            Err(e)
         }
-        _ => 0,
+        _ => Ok(()),
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
-        .setting(AppSettings::AllowNegativeNumbers)
+        .override_usage(format_usage(USAGE))
+        .allow_negative_numbers(true)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::DELIMITER)
-                .short("d")
+            Arg::new(options::DELIMITER)
+                .short('d')
                 .long(options::DELIMITER)
                 .value_name("X")
                 .help("use X instead of whitespace for field delimiter"),
         )
         .arg(
-            Arg::with_name(options::FIELD)
+            Arg::new(options::FIELD)
                 .long(options::FIELD)
                 .help("replace the numbers in these input fields (default=1) see FIELDS below")
                 .value_name("FIELDS")
                 .default_value(options::FIELD_DEFAULT),
         )
         .arg(
-            Arg::with_name(options::FROM)
+            Arg::new(options::FROM)
                 .long(options::FROM)
                 .help("auto-scale input numbers to UNITs; see UNIT below")
                 .value_name("UNIT")
                 .default_value(options::FROM_DEFAULT),
         )
         .arg(
-            Arg::with_name(options::TO)
+            Arg::new(options::TO)
                 .long(options::TO)
                 .help("auto-scale output numbers to UNITs; see UNIT below")
                 .value_name("UNIT")
                 .default_value(options::TO_DEFAULT),
         )
         .arg(
-            Arg::with_name(options::PADDING)
+            Arg::new(options::PADDING)
                 .long(options::PADDING)
                 .help(
                     "pad the output to N characters; positive N will \
@@ -221,18 +234,18 @@ pub fn uu_app() -> App<'static, 'static> {
                 .value_name("N"),
         )
         .arg(
-            Arg::with_name(options::HEADER)
+            Arg::new(options::HEADER)
                 .long(options::HEADER)
                 .help(
                     "print (without converting) the first N header lines; \
                      N defaults to 1 if not specified",
                 )
                 .value_name("N")
-                .default_value(options::HEADER_DEFAULT)
+                .default_missing_value(options::HEADER_DEFAULT)
                 .hide_default_value(true),
         )
         .arg(
-            Arg::with_name(options::ROUND)
+            Arg::new(options::ROUND)
                 .long(options::ROUND)
                 .help(
                     "use METHOD for rounding when scaling; METHOD can be: up,\
@@ -242,5 +255,80 @@ pub fn uu_app() -> App<'static, 'static> {
                 .default_value("from-zero")
                 .possible_values(&["up", "down", "from-zero", "towards-zero", "nearest"]),
         )
-        .arg(Arg::with_name(options::NUMBER).hidden(true).multiple(true))
+        .arg(
+            Arg::new(options::SUFFIX)
+                .long(options::SUFFIX)
+                .help(
+                    "print SUFFIX after each formatted number, and accept \
+                    inputs optionally ending with SUFFIX",
+                )
+                .value_name("SUFFIX"),
+        )
+        .arg(
+            Arg::new(options::NUMBER)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{handle_buffer, NumfmtOptions, Range, RoundMethod, TransformOptions, Unit};
+    use std::io::{BufReader, Error, ErrorKind, Read};
+    struct MockBuffer {}
+
+    impl Read for MockBuffer {
+        fn read(&mut self, _: &mut [u8]) -> Result<usize, Error> {
+            Err(Error::new(ErrorKind::BrokenPipe, "broken pipe"))
+        }
+    }
+
+    fn get_valid_options() -> NumfmtOptions {
+        NumfmtOptions {
+            transform: TransformOptions {
+                from: Unit::None,
+                to: Unit::None,
+            },
+            padding: 10,
+            header: 1,
+            fields: vec![Range { low: 0, high: 1 }],
+            delimiter: None,
+            round: RoundMethod::Nearest,
+            suffix: None,
+        }
+    }
+
+    #[test]
+    fn broken_buffer_returns_io_error() {
+        let mock_buffer = MockBuffer {};
+        let result = handle_buffer(BufReader::new(mock_buffer), &get_valid_options())
+            .expect_err("returned Ok after receiving IO error");
+        let result_debug = format!("{:?}", result);
+        let result_display = format!("{}", result);
+        assert_eq!(result_debug, "IoError(\"broken pipe\")");
+        assert_eq!(result_display, "broken pipe");
+        assert_eq!(result.code(), 1);
+    }
+
+    #[test]
+    fn non_numeric_returns_formatting_error() {
+        let input_value = b"135\nhello";
+        let result = handle_buffer(BufReader::new(&input_value[..]), &get_valid_options())
+            .expect_err("returned Ok after receiving improperly formatted input");
+        let result_debug = format!("{:?}", result);
+        let result_display = format!("{}", result);
+        assert_eq!(
+            result_debug,
+            "FormattingError(\"invalid suffix in input: 'hello'\")"
+        );
+        assert_eq!(result_display, "invalid suffix in input: 'hello'");
+        assert_eq!(result.code(), 2);
+    }
+
+    #[test]
+    fn valid_input_returns_ok() {
+        let input_value = b"165\n100\n300\n500";
+        let result = handle_buffer(BufReader::new(&input_value[..]), &get_valid_options());
+        assert!(result.is_ok(), "did not return Ok for valid input");
+    }
 }
diff --git a/src/uu/numfmt/src/options.rs b/src/uu/numfmt/src/options.rs
index 59bf9d8d3..f61d4c704 100644
--- a/src/uu/numfmt/src/options.rs
+++ b/src/uu/numfmt/src/options.rs
@@ -11,6 +11,7 @@ pub const HEADER_DEFAULT: &str = "1";
 pub const NUMBER: &str = "NUMBER";
 pub const PADDING: &str = "padding";
 pub const ROUND: &str = "round";
+pub const SUFFIX: &str = "suffix";
 pub const TO: &str = "to";
 pub const TO_DEFAULT: &str = "none";
 
@@ -26,6 +27,7 @@ pub struct NumfmtOptions {
     pub fields: Vec<Range>,
     pub delimiter: Option<String>,
     pub round: RoundMethod,
+    pub suffix: Option<String>,
 }
 
 #[derive(Clone, Copy)]
@@ -40,23 +42,23 @@ pub enum RoundMethod {
 impl RoundMethod {
     pub fn round(&self, f: f64) -> f64 {
         match self {
-            RoundMethod::Up => f.ceil(),
-            RoundMethod::Down => f.floor(),
-            RoundMethod::FromZero => {
+            Self::Up => f.ceil(),
+            Self::Down => f.floor(),
+            Self::FromZero => {
                 if f < 0.0 {
                     f.floor()
                 } else {
                     f.ceil()
                 }
             }
-            RoundMethod::TowardsZero => {
+            Self::TowardsZero => {
                 if f < 0.0 {
                     f.ceil()
                 } else {
                     f.floor()
                 }
             }
-            RoundMethod::Nearest => f.round(),
+            Self::Nearest => f.round(),
         }
     }
 }
diff --git a/src/uu/od/Cargo.toml b/src/uu/od/Cargo.toml
index a6b5bc433..d6cb3235d 100644
--- a/src/uu/od/Cargo.toml
+++ b/src/uu/od/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_od"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "od ~ (uutils) display formatted representation of input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/od"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/od"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -16,16 +16,10 @@ path = "src/od.rs"
 
 [dependencies]
 byteorder = "1.3.2"
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 half = "1.6"
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "od"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/od/LICENSE b/src/uu/od/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/od/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/od/src/formatteriteminfo.rs b/src/uu/od/src/formatteriteminfo.rs
index 13cf62246..9778b68f4 100644
--- a/src/uu/od/src/formatteriteminfo.rs
+++ b/src/uu/od/src/formatteriteminfo.rs
@@ -18,7 +18,7 @@ impl Clone for FormatWriter {
 }
 
 impl PartialEq for FormatWriter {
-    fn eq(&self, other: &FormatWriter) -> bool {
+    fn eq(&self, other: &Self) -> bool {
         use crate::formatteriteminfo::FormatWriter::*;
 
         match (self, other) {
diff --git a/src/uu/od/src/inputoffset.rs b/src/uu/od/src/inputoffset.rs
index 2bdf03ca4..25b439291 100644
--- a/src/uu/od/src/inputoffset.rs
+++ b/src/uu/od/src/inputoffset.rs
@@ -11,16 +11,16 @@ pub struct InputOffset {
     /// The radix to print the byte offset. NoPrefix will not print a byte offset.
     radix: Radix,
     /// The current position. Initialize at `new`, increase using `increase_position`.
-    byte_pos: usize,
+    byte_pos: u64,
     /// An optional label printed in parentheses, typically different from `byte_pos`,
     /// but will increase with the same value if `byte_pos` in increased.
-    label: Option<usize>,
+    label: Option<u64>,
 }
 
 impl InputOffset {
     /// creates a new `InputOffset` using the provided values.
-    pub fn new(radix: Radix, byte_pos: usize, label: Option<usize>) -> InputOffset {
-        InputOffset {
+    pub fn new(radix: Radix, byte_pos: u64, label: Option<u64>) -> Self {
+        Self {
             radix,
             byte_pos,
             label,
@@ -28,7 +28,7 @@ impl InputOffset {
     }
 
     /// Increase `byte_pos` and `label` if a label is used.
-    pub fn increase_position(&mut self, n: usize) {
+    pub fn increase_position(&mut self, n: u64) {
         self.byte_pos += n;
         if let Some(l) = self.label {
             self.label = Some(l + n);
diff --git a/src/uu/od/src/main.rs b/src/uu/od/src/main.rs
index 3f30d15e8..d8e0b2c8c 100644
--- a/src/uu/od/src/main.rs
+++ b/src/uu/od/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_od);
+uucore::bin!(uu_od);
diff --git a/src/uu/od/src/mockstream.rs b/src/uu/od/src/mockstream.rs
index 5beecbf9c..a1ce0dd68 100644
--- a/src/uu/od/src/mockstream.rs
+++ b/src/uu/od/src/mockstream.rs
@@ -54,8 +54,8 @@ impl FailingMockStream {
     ///
     /// When `read` or `write` is called, it will return an error `repeat_count` times.
     /// `kind` and `message` can be specified to define the exact error.
-    pub fn new(kind: ErrorKind, message: &'static str, repeat_count: i32) -> FailingMockStream {
-        FailingMockStream {
+    pub fn new(kind: ErrorKind, message: &'static str, repeat_count: i32) -> Self {
+        Self {
             kind,
             message,
             repeat_count,
diff --git a/src/uu/od/src/multifilereader.rs b/src/uu/od/src/multifilereader.rs
index 1b3aba03d..7fbd75358 100644
--- a/src/uu/od/src/multifilereader.rs
+++ b/src/uu/od/src/multifilereader.rs
@@ -60,7 +60,7 @@ impl<'b> MultifileReader<'b> {
                             // then move on the the next file.
                             // This matches the behavior of the original `od`
                             show_error!("{}: {}", fname.maybe_quote(), e);
-                            self.any_err = true
+                            self.any_err = true;
                         }
                     }
                 }
diff --git a/src/uu/od/src/od.rs b/src/uu/od/src/od.rs
index e9983f991..81cfb94de 100644
--- a/src/uu/od/src/od.rs
+++ b/src/uu/od/src/od.rs
@@ -5,7 +5,7 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-// spell-checker:ignore (clap) DontDelimitTrailingValues
+// spell-checker:ignore (clap) dont
 // spell-checker:ignore (ToDO) formatteriteminfo inputdecoder inputoffset mockstream nrofbytes partialreader odfunc multifile exitcode
 
 #[macro_use]
@@ -29,6 +29,7 @@ mod prn_float;
 mod prn_int;
 
 use std::cmp;
+use std::convert::TryFrom;
 
 use crate::byteorder_io::*;
 use crate::formatteriteminfo::*;
@@ -42,18 +43,20 @@ use crate::parse_nrofbytes::parse_number_of_bytes;
 use crate::partialreader::*;
 use crate::peekreader::*;
 use crate::prn_char::format_ascii_dump;
-use clap::{self, crate_version, AppSettings, Arg, ArgMatches};
+use clap::{crate_version, AppSettings, Arg, ArgMatches, Command};
 use uucore::display::Quotable;
+use uucore::error::{UResult, USimpleError};
+use uucore::format_usage;
 use uucore::parse_size::ParseSizeError;
 use uucore::InvalidEncodingHandling;
 
 const PEEK_BUFFER_SIZE: usize = 4; // utf-8 can be 4 bytes
 static ABOUT: &str = "dump files in octal and other formats";
 
-static USAGE: &str = r#"
-    od [OPTION]... [--] [FILENAME]...
-    od [-abcdDefFhHiIlLoOsxX] [FILENAME] [[+][0x]OFFSET[.][b]]
-    od --traditional [OPTION]... [FILENAME] [[+][0x]OFFSET[.][b] [[+][0x]LABEL[.][b]]]"#;
+static USAGE: &str = "\
+    {} [OPTION]... [--] [FILENAME]...
+    {} [-abcdDefFhHiIlLoOsxX] [FILENAME] [[+][0x]OFFSET[.][b]]
+    {} --traditional [OPTION]... [FILENAME] [[+][0x]OFFSET[.][b] [[+][0x]LABEL[.][b]]]";
 
 static LONG_HELP: &str = r#"
 Displays data in various human-readable formats. If multiple formats are
@@ -95,6 +98,7 @@ If an error occurred, a diagnostic message will be printed to stderr, and the
 exitcode will be non-zero."#;
 
 pub(crate) mod options {
+    pub const HELP: &str = "help";
     pub const ADDRESS_RADIX: &str = "address-radix";
     pub const SKIP_BYTES: &str = "skip-bytes";
     pub const READ_BYTES: &str = "read-bytes";
@@ -109,9 +113,9 @@ pub(crate) mod options {
 
 struct OdOptions {
     byte_order: ByteOrder,
-    skip_bytes: usize,
-    read_bytes: Option<usize>,
-    label: Option<usize>,
+    skip_bytes: u64,
+    read_bytes: Option<u64>,
+    label: Option<u64>,
     input_strings: Vec<String>,
     formats: Vec<ParsedFormatterItemInfo>,
     line_bytes: usize,
@@ -120,25 +124,36 @@ struct OdOptions {
 }
 
 impl OdOptions {
-    fn new(matches: ArgMatches, args: Vec<String>) -> Result<OdOptions, String> {
+    fn new(matches: &ArgMatches, args: &[String]) -> UResult<Self> {
         let byte_order = match matches.value_of(options::ENDIAN) {
             None => ByteOrder::Native,
             Some("little") => ByteOrder::Little,
             Some("big") => ByteOrder::Big,
             Some(s) => {
-                return Err(format!("Invalid argument --endian={}", s));
+                return Err(USimpleError::new(
+                    1,
+                    format!("Invalid argument --endian={}", s),
+                ));
             }
         };
 
-        let mut skip_bytes = matches.value_of(options::SKIP_BYTES).map_or(0, |s| {
-            parse_number_of_bytes(s).unwrap_or_else(|e| {
-                crash!(1, "{}", format_error_message(e, s, options::SKIP_BYTES))
-            })
-        });
+        let mut skip_bytes = match matches.value_of(options::SKIP_BYTES) {
+            None => 0,
+            Some(s) => match parse_number_of_bytes(s) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format_error_message(&e, s, options::SKIP_BYTES),
+                    ))
+                }
+            },
+        };
 
-        let mut label: Option<usize> = None;
+        let mut label: Option<u64> = None;
 
-        let parsed_input = parse_inputs(&matches).map_err(|e| format!("Invalid inputs: {}", e))?;
+        let parsed_input = parse_inputs(matches)
+            .map_err(|e| USimpleError::new(1, format!("Invalid inputs: {}", e)))?;
         let input_strings = match parsed_input {
             CommandLineInputs::FileNames(v) => v,
             CommandLineInputs::FileAndOffset((f, s, l)) => {
@@ -148,15 +163,27 @@ impl OdOptions {
             }
         };
 
-        let formats = parse_format_flags(&args)?;
+        let formats = parse_format_flags(args).map_err(|e| USimpleError::new(1, e))?;
 
-        let mut line_bytes = matches.value_of(options::WIDTH).map_or(16, |s| {
-            if matches.occurrences_of(options::WIDTH) == 0 {
-                return 16;
-            };
-            parse_number_of_bytes(s)
-                .unwrap_or_else(|e| crash!(1, "{}", format_error_message(e, s, options::WIDTH)))
-        });
+        let mut line_bytes = match matches.value_of(options::WIDTH) {
+            None => 16,
+            Some(s) => {
+                if matches.occurrences_of(options::WIDTH) == 0 {
+                    16
+                } else {
+                    match parse_number_of_bytes(s) {
+                        Ok(n) => usize::try_from(n)
+                            .map_err(|_| USimpleError::new(1, format!("‘{}‘ is too large", s)))?,
+                        Err(e) => {
+                            return Err(USimpleError::new(
+                                1,
+                                format_error_message(&e, s, options::WIDTH),
+                            ))
+                        }
+                    }
+                }
+            }
+        };
 
         let min_bytes = formats.iter().fold(1, |max, next| {
             cmp::max(max, next.formatter_item_info.byte_size)
@@ -168,18 +195,28 @@ impl OdOptions {
 
         let output_duplicates = matches.is_present(options::OUTPUT_DUPLICATES);
 
-        let read_bytes = matches.value_of(options::READ_BYTES).map(|s| {
-            parse_number_of_bytes(s).unwrap_or_else(|e| {
-                crash!(1, "{}", format_error_message(e, s, options::READ_BYTES))
-            })
-        });
+        let read_bytes = match matches.value_of(options::READ_BYTES) {
+            None => None,
+            Some(s) => match parse_number_of_bytes(s) {
+                Ok(n) => Some(n),
+                Err(e) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format_error_message(&e, s, options::READ_BYTES),
+                    ))
+                }
+            },
+        };
 
         let radix = match matches.value_of(options::ADDRESS_RADIX) {
             None => Radix::Octal,
             Some(s) => {
                 let st = s.as_bytes();
                 if st.len() != 1 {
-                    return Err("Radix must be one of [d, o, n, x]".to_string());
+                    return Err(USimpleError::new(
+                        1,
+                        "Radix must be one of [d, o, n, x]".to_string(),
+                    ));
                 } else {
                     let radix: char =
                         *(st.get(0).expect("byte string of length 1 lacks a 0th elem")) as char;
@@ -188,13 +225,18 @@ impl OdOptions {
                         'x' => Radix::Hexadecimal,
                         'o' => Radix::Octal,
                         'n' => Radix::NoPrefix,
-                        _ => return Err("Radix must be one of [d, o, n, x]".to_string()),
+                        _ => {
+                            return Err(USimpleError::new(
+                                1,
+                                "Radix must be one of [d, o, n, x]".to_string(),
+                            ))
+                        }
                     }
                 }
             }
         };
 
-        Ok(OdOptions {
+        Ok(Self {
             byte_order,
             skip_bytes,
             read_bytes,
@@ -210,7 +252,8 @@ impl OdOptions {
 
 /// parses and validates command line parameters, prepares data structures,
 /// opens the input and calls `odfunc` to process the input.
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
@@ -221,12 +264,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         .clone() // Clone to reuse clap_opts to print help
         .get_matches_from(args.clone());
 
-    let od_options = match OdOptions::new(clap_matches, args) {
-        Err(s) => {
-            crash!(1, "{}", s);
-        }
-        Ok(o) => o,
-    };
+    let od_options = OdOptions::new(&clap_matches, &args)?;
 
     let mut input_offset =
         InputOffset::new(od_options.radix, od_options.skip_bytes, od_options.label);
@@ -252,229 +290,231 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     odfunc(&mut input_offset, &mut input_decoder, &output_info)
 }
 
-pub fn uu_app() -> clap::App<'static, 'static> {
-    clap::App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .after_help(LONG_HELP)
+        .trailing_var_arg(true)
+        .dont_delimit_trailing_values(true)
+        .infer_long_args(true)
+        .setting(AppSettings::DeriveDisplayOrder)
         .arg(
-            Arg::with_name(options::ADDRESS_RADIX)
-                .short("A")
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information.")
+        )
+        .arg(
+            Arg::new(options::ADDRESS_RADIX)
+                .short('A')
                 .long(options::ADDRESS_RADIX)
                 .help("Select the base in which file offsets are printed.")
                 .value_name("RADIX"),
         )
         .arg(
-            Arg::with_name(options::SKIP_BYTES)
-                .short("j")
+            Arg::new(options::SKIP_BYTES)
+                .short('j')
                 .long(options::SKIP_BYTES)
                 .help("Skip bytes input bytes before formatting and writing.")
                 .value_name("BYTES"),
         )
         .arg(
-            Arg::with_name(options::READ_BYTES)
-                .short("N")
+            Arg::new(options::READ_BYTES)
+                .short('N')
                 .long(options::READ_BYTES)
                 .help("limit dump to BYTES input bytes")
                 .value_name("BYTES"),
         )
         .arg(
-            Arg::with_name(options::ENDIAN)
+            Arg::new(options::ENDIAN)
                 .long(options::ENDIAN)
                 .help("byte order to use for multi-byte formats")
                 .possible_values(&["big", "little"])
                 .value_name("big|little"),
         )
         .arg(
-            Arg::with_name(options::STRINGS)
-                .short("S")
+            Arg::new(options::STRINGS)
+                .short('S')
                 .long(options::STRINGS)
                 .help(
                     "NotImplemented: output strings of at least BYTES graphic chars. 3 is assumed when \
                      BYTES is not specified.",
                 )
-                .default_value("3")
+                .default_missing_value("3")
                 .value_name("BYTES"),
         )
         .arg(
-            Arg::with_name("a")
-                .short("a")
+            Arg::new("a")
+                .short('a')
                 .help("named characters, ignoring high-order bit")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("b")
-                .short("b")
+            Arg::new("b")
+                .short('b')
                 .help("octal bytes")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("c")
-                .short("c")
+            Arg::new("c")
+                .short('c')
                 .help("ASCII characters or backslash escapes")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("d")
-                .short("d")
+            Arg::new("d")
+                .short('d')
                 .help("unsigned decimal 2-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("D")
-                .short("D")
+            Arg::new("D")
+                .short('D')
                 .help("unsigned decimal 4-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("o")
-                .short("o")
+            Arg::new("o")
+                .short('o')
                 .help("octal 2-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("I")
-                .short("I")
+            Arg::new("I")
+                .short('I')
                 .help("decimal 8-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("L")
-                .short("L")
+            Arg::new("L")
+                .short('L')
                 .help("decimal 8-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("i")
-                .short("i")
+            Arg::new("i")
+                .short('i')
                 .help("decimal 4-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("l")
-                .short("l")
+            Arg::new("l")
+                .short('l')
                 .help("decimal 8-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("x")
-                .short("x")
+            Arg::new("x")
+                .short('x')
                 .help("hexadecimal 2-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("h")
-                .short("h")
+            Arg::new("h")
+                .short('h')
                 .help("hexadecimal 2-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("O")
-                .short("O")
+            Arg::new("O")
+                .short('O')
                 .help("octal 4-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("s")
-                .short("s")
+            Arg::new("s")
+                .short('s')
                 .help("decimal 2-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("X")
-                .short("X")
+            Arg::new("X")
+                .short('X')
                 .help("hexadecimal 4-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("H")
-                .short("H")
+            Arg::new("H")
+                .short('H')
                 .help("hexadecimal 4-byte units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("e")
-                .short("e")
+            Arg::new("e")
+                .short('e')
                 .help("floating point double precision (64-bit) units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("f")
-                .short("f")
+            Arg::new("f")
+                .short('f')
                 .help("floating point double precision (32-bit) units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name("F")
-                .short("F")
+            Arg::new("F")
+                .short('F')
                 .help("floating point double precision (64-bit) units")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::FORMAT)
-                .short("t")
-                .long(options::FORMAT)
+            Arg::new(options::FORMAT)
+                .short('t')
+                .long("format")
                 .help("select output format or formats")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .number_of_values(1)
                 .value_name("TYPE"),
         )
         .arg(
-            Arg::with_name(options::OUTPUT_DUPLICATES)
-                .short("v")
+            Arg::new(options::OUTPUT_DUPLICATES)
+                .short('v')
                 .long(options::OUTPUT_DUPLICATES)
                 .help("do not use * to mark line suppression")
-                .takes_value(false)
-                .possible_values(&["big", "little"]),
+                .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::WIDTH)
-                .short("w")
+            Arg::new(options::WIDTH)
+                .short('w')
                 .long(options::WIDTH)
                 .help(
                     "output BYTES bytes per output line. 32 is implied when BYTES is not \
                      specified.",
                 )
-                .default_value("32")
+                .default_missing_value("32")
                 .value_name("BYTES"),
         )
         .arg(
-            Arg::with_name(options::TRADITIONAL)
+            Arg::new(options::TRADITIONAL)
                 .long(options::TRADITIONAL)
                 .help("compatibility mode with one input, offset and label.")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::FILENAME)
-                .hidden(true)
-                .multiple(true),
+            Arg::new(options::FILENAME)
+                .hide(true)
+                .multiple_occurrences(true),
         )
-        .settings(&[
-            AppSettings::TrailingVarArg,
-            AppSettings::DontDelimitTrailingValues,
-            AppSettings::DisableVersion,
-            AppSettings::DeriveDisplayOrder,
-        ])
 }
 
 /// Loops through the input line by line, calling print_bytes to take care of the output.
@@ -482,7 +522,7 @@ fn odfunc<I>(
     input_offset: &mut InputOffset,
     input_decoder: &mut InputDecoder<I>,
     output_info: &OutputInfo,
-) -> i32
+) -> UResult<()>
 where
     I: PeekRead + HasError,
 {
@@ -535,20 +575,20 @@ where
                     );
                 }
 
-                input_offset.increase_position(length);
+                input_offset.increase_position(length as u64);
             }
             Err(e) => {
                 show_error!("{}", e);
                 input_offset.print_final_offset();
-                return 1;
+                return Err(1.into());
             }
         };
     }
 
     if input_decoder.has_error() {
-        1
+        Err(1.into())
     } else {
-        0
+        Ok(())
     }
 }
 
@@ -614,8 +654,8 @@ fn print_bytes(prefix: &str, input_decoder: &MemoryDecoder, output_info: &Output
 /// `read_bytes` is an optional limit to the number of bytes to read
 fn open_input_peek_reader(
     input_strings: &[String],
-    skip_bytes: usize,
-    read_bytes: Option<usize>,
+    skip_bytes: u64,
+    read_bytes: Option<u64>,
 ) -> PeekReader<PartialReader<MultifileReader>> {
     // should return  "impl PeekRead + Read + HasError" when supported in (stable) rust
     let inputs = input_strings
@@ -631,7 +671,7 @@ fn open_input_peek_reader(
     PeekReader::new(pr)
 }
 
-fn format_error_message(error: ParseSizeError, s: &str, option: &str) -> String {
+fn format_error_message(error: &ParseSizeError, s: &str, option: &str) -> String {
     // NOTE:
     // GNU's od echos affected flag, -N or --read-bytes (-j or --skip-bytes, etc.), depending user's selection
     // GNU's od does distinguish between "invalid (suffix in) argument"
diff --git a/src/uu/od/src/output_info.rs b/src/uu/od/src/output_info.rs
index cf050475a..60cbaf5ab 100644
--- a/src/uu/od/src/output_info.rs
+++ b/src/uu/od/src/output_info.rs
@@ -54,7 +54,7 @@ impl OutputInfo {
         line_bytes: usize,
         formats: &[ParsedFormatterItemInfo],
         output_duplicates: bool,
-    ) -> OutputInfo {
+    ) -> Self {
         let byte_size_block = formats.iter().fold(1, |max, next| {
             cmp::max(max, next.formatter_item_info.byte_size)
         });
@@ -68,9 +68,9 @@ impl OutputInfo {
         let print_width_line = print_width_block * (line_bytes / byte_size_block);
 
         let spaced_formatters =
-            OutputInfo::create_spaced_formatter_info(formats, byte_size_block, print_width_block);
+            Self::create_spaced_formatter_info(formats, byte_size_block, print_width_block);
 
-        OutputInfo {
+        Self {
             byte_size_line: line_bytes,
             print_width_line,
             byte_size_block,
@@ -90,7 +90,7 @@ impl OutputInfo {
             .map(|f| SpacedFormatterItemInfo {
                 formatter_item_info: f.formatter_item_info,
                 add_ascii_dump: f.add_ascii_dump,
-                spacing: OutputInfo::calculate_alignment(f, byte_size_block, print_width_block),
+                spacing: Self::calculate_alignment(f, byte_size_block, print_width_block),
             })
             .collect()
     }
diff --git a/src/uu/od/src/parse_formats.rs b/src/uu/od/src/parse_formats.rs
index 301bb5154..21971445d 100644
--- a/src/uu/od/src/parse_formats.rs
+++ b/src/uu/od/src/parse_formats.rs
@@ -14,11 +14,8 @@ pub struct ParsedFormatterItemInfo {
 }
 
 impl ParsedFormatterItemInfo {
-    pub fn new(
-        formatter_item_info: FormatterItemInfo,
-        add_ascii_dump: bool,
-    ) -> ParsedFormatterItemInfo {
-        ParsedFormatterItemInfo {
+    pub fn new(formatter_item_info: FormatterItemInfo, add_ascii_dump: bool) -> Self {
+        Self {
             formatter_item_info,
             add_ascii_dump,
         }
@@ -138,7 +135,7 @@ pub fn parse_format_flags(args: &[String]) -> Result<Vec<ParsedFormatterItemInfo
                 } else {
                     // not every option is a format
                     if let Some(r) = od_argument_traditional_format(c) {
-                        formats.push(ParsedFormatterItemInfo::new(r, false))
+                        formats.push(ParsedFormatterItemInfo::new(r, false));
                     }
                 }
             }
diff --git a/src/uu/od/src/parse_inputs.rs b/src/uu/od/src/parse_inputs.rs
index 419b7173d..45e664ce3 100644
--- a/src/uu/od/src/parse_inputs.rs
+++ b/src/uu/od/src/parse_inputs.rs
@@ -10,7 +10,7 @@ pub trait CommandLineOpts {
 }
 
 /// Implementation for `getopts`
-impl<'a> CommandLineOpts for ArgMatches<'a> {
+impl<'a> CommandLineOpts for ArgMatches {
     fn inputs(&self) -> Vec<&str> {
         self.values_of(options::FILENAME)
             .map(|values| values.collect())
@@ -32,7 +32,7 @@ impl<'a> CommandLineOpts for ArgMatches<'a> {
 #[derive(PartialEq, Debug)]
 pub enum CommandLineInputs {
     FileNames(Vec<String>),
-    FileAndOffset((String, usize, Option<usize>)),
+    FileAndOffset((String, u64, Option<u64>)),
 }
 
 /// Interprets the command line inputs of od.
@@ -46,14 +46,21 @@ pub fn parse_inputs(matches: &dyn CommandLineOpts) -> Result<CommandLineInputs,
     let mut input_strings = matches.inputs();
 
     if matches.opts_present(&["traditional"]) {
-        return parse_inputs_traditional(input_strings);
+        return parse_inputs_traditional(&input_strings);
     }
 
     // test if command line contains: [file] <offset>
     // fall-through if no (valid) offset is found
     if input_strings.len() == 1 || input_strings.len() == 2 {
         // if any of the options -A, -j, -N, -t, -v or -w are present there is no offset
-        if !matches.opts_present(&["A", "j", "N", "t", "v", "w"]) {
+        if !matches.opts_present(&[
+            options::ADDRESS_RADIX,
+            options::READ_BYTES,
+            options::SKIP_BYTES,
+            options::FORMAT,
+            options::OUTPUT_DUPLICATES,
+            options::WIDTH,
+        ]) {
             // test if the last input can be parsed as an offset.
             let offset = parse_offset_operand(input_strings[input_strings.len() - 1]);
             if let Ok(n) = offset {
@@ -84,7 +91,7 @@ pub fn parse_inputs(matches: &dyn CommandLineOpts) -> Result<CommandLineInputs,
 ///
 /// normally returns CommandLineInputs::FileAndOffset, but if no offset is found,
 /// it returns CommandLineInputs::FileNames (also to differentiate from the offset == 0)
-pub fn parse_inputs_traditional(input_strings: Vec<&str>) -> Result<CommandLineInputs, String> {
+pub fn parse_inputs_traditional(input_strings: &[&str]) -> Result<CommandLineInputs, String> {
     match input_strings.len() {
         0 => Ok(CommandLineInputs::FileNames(vec!["-".to_string()])),
         1 => {
@@ -134,7 +141,7 @@ pub fn parse_inputs_traditional(input_strings: Vec<&str>) -> Result<CommandLineI
 }
 
 /// parses format used by offset and label on the command line
-pub fn parse_offset_operand(s: &str) -> Result<usize, &'static str> {
+pub fn parse_offset_operand(s: &str) -> Result<u64, &'static str> {
     let mut start = 0;
     let mut len = s.len();
     let mut radix = 8;
@@ -157,7 +164,7 @@ pub fn parse_offset_operand(s: &str) -> Result<usize, &'static str> {
             radix = 10;
         }
     }
-    match usize::from_str_radix(&s[start..len], radix) {
+    match u64::from_str_radix(&s[start..len], radix) {
         Ok(i) => Ok(i * multiply),
         Err(_) => Err("parse failed"),
     }
@@ -166,61 +173,28 @@ pub fn parse_offset_operand(s: &str) -> Result<usize, &'static str> {
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    /// A mock for the command line options type
-    ///
-    /// `inputs` are all command line parameters which do not belong to an option.
-    /// `option_names` are the names of the options on the command line.
-    struct MockOptions<'a> {
-        inputs: Vec<String>,
-        option_names: Vec<&'a str>,
-    }
-
-    impl<'a> MockOptions<'a> {
-        fn new(inputs: Vec<&'a str>, option_names: Vec<&'a str>) -> MockOptions<'a> {
-            MockOptions {
-                inputs: inputs.iter().map(|&s| s.to_string()).collect::<Vec<_>>(),
-                option_names,
-            }
-        }
-    }
-
-    impl<'a> CommandLineOpts for MockOptions<'a> {
-        fn inputs(&self) -> Vec<&str> {
-            self.inputs.iter().map(|s| s.as_str()).collect()
-        }
-        fn opts_present(&self, opts: &[&str]) -> bool {
-            for expected in opts.iter() {
-                for actual in self.option_names.iter() {
-                    if *expected == *actual {
-                        return true;
-                    }
-                }
-            }
-            false
-        }
-    }
+    use crate::uu_app;
 
     #[test]
     fn test_parse_inputs_normal() {
         assert_eq!(
             CommandLineInputs::FileNames(vec!["-".to_string()]),
-            parse_inputs(&MockOptions::new(vec![], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od"])).unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileNames(vec!["-".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["-"], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "-"])).unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileNames(vec!["file1".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["file1"], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "file1"])).unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileNames(vec!["file1".to_string(), "file2".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["file1", "file2"], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "file1", "file2"])).unwrap()
         );
 
         assert_eq!(
@@ -229,7 +203,7 @@ mod tests {
                 "file1".to_string(),
                 "file2".to_string(),
             ]),
-            parse_inputs(&MockOptions::new(vec!["-", "file1", "file2"], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "-", "file1", "file2"])).unwrap()
         );
     }
 
@@ -238,58 +212,58 @@ mod tests {
         // offset is found without filename, so stdin will be used.
         assert_eq!(
             CommandLineInputs::FileAndOffset(("-".to_string(), 8, None)),
-            parse_inputs(&MockOptions::new(vec!["+10"], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "+10"])).unwrap()
         );
 
         // offset must start with "+" if no input is specified.
         assert_eq!(
             CommandLineInputs::FileNames(vec!["10".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["10"], vec![""])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "10"])).unwrap()
         );
 
         // offset is not valid, so it is considered a filename.
         assert_eq!(
             CommandLineInputs::FileNames(vec!["+10a".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["+10a"], vec![""])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "+10a"])).unwrap()
         );
 
         // if -j is included in the command line, there cannot be an offset.
         assert_eq!(
             CommandLineInputs::FileNames(vec!["+10".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["+10"], vec!["j"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "-j10", "+10"])).unwrap()
         );
 
         // if -v is included in the command line, there cannot be an offset.
         assert_eq!(
             CommandLineInputs::FileNames(vec!["+10".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["+10"], vec!["o", "v"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "-o", "-v", "+10"])).unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileAndOffset(("file1".to_string(), 8, None)),
-            parse_inputs(&MockOptions::new(vec!["file1", "+10"], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "file1", "+10"])).unwrap()
         );
 
         // offset does not need to start with "+" if a filename is included.
         assert_eq!(
             CommandLineInputs::FileAndOffset(("file1".to_string(), 8, None)),
-            parse_inputs(&MockOptions::new(vec!["file1", "10"], vec![])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "file1", "10"])).unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileNames(vec!["file1".to_string(), "+10a".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["file1", "+10a"], vec![""])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "file1", "+10a"])).unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileNames(vec!["file1".to_string(), "+10".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["file1", "+10"], vec!["j"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "-j10", "file1", "+10"])).unwrap()
         );
 
         // offset must be last on the command line
         assert_eq!(
             CommandLineInputs::FileNames(vec!["+10".to_string(), "file1".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["+10", "file1"], vec![""])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "+10", "file1"])).unwrap()
         );
     }
 
@@ -298,63 +272,67 @@ mod tests {
         // it should not return FileAndOffset to signal no offset was entered on the command line.
         assert_eq!(
             CommandLineInputs::FileNames(vec!["-".to_string()]),
-            parse_inputs(&MockOptions::new(vec![], vec!["traditional"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional"])).unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileNames(vec!["file1".to_string()]),
-            parse_inputs(&MockOptions::new(vec!["file1"], vec!["traditional"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional", "file1"])).unwrap()
         );
 
         // offset does not need to start with a +
         assert_eq!(
             CommandLineInputs::FileAndOffset(("-".to_string(), 8, None)),
-            parse_inputs(&MockOptions::new(vec!["10"], vec!["traditional"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional", "10"])).unwrap()
         );
 
         // valid offset and valid label
         assert_eq!(
             CommandLineInputs::FileAndOffset(("-".to_string(), 8, Some(8))),
-            parse_inputs(&MockOptions::new(vec!["10", "10"], vec!["traditional"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional", "10", "10"]))
+                .unwrap()
         );
 
         assert_eq!(
             CommandLineInputs::FileAndOffset(("file1".to_string(), 8, None)),
-            parse_inputs(&MockOptions::new(vec!["file1", "10"], vec!["traditional"])).unwrap()
+            parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional", "file1", "10"]))
+                .unwrap()
         );
 
         // only one file is allowed, it must be the first
-        parse_inputs(&MockOptions::new(vec!["10", "file1"], vec!["traditional"])).unwrap_err();
+        parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional", "10", "file1"]))
+            .unwrap_err();
 
         assert_eq!(
             CommandLineInputs::FileAndOffset(("file1".to_string(), 8, Some(8))),
-            parse_inputs(&MockOptions::new(
-                vec!["file1", "10", "10"],
-                vec!["traditional"]
-            ))
+            parse_inputs(&uu_app().get_matches_from(vec![
+                "od",
+                "--traditional",
+                "file1",
+                "10",
+                "10"
+            ]))
             .unwrap()
         );
 
-        parse_inputs(&MockOptions::new(
-            vec!["10", "file1", "10"],
-            vec!["traditional"],
-        ))
-        .unwrap_err();
+        parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional", "10", "file1", "10"]))
+            .unwrap_err();
 
-        parse_inputs(&MockOptions::new(
-            vec!["10", "10", "file1"],
-            vec!["traditional"],
-        ))
-        .unwrap_err();
+        parse_inputs(&uu_app().get_matches_from(vec!["od", "--traditional", "10", "10", "file1"]))
+            .unwrap_err();
 
-        parse_inputs(&MockOptions::new(
-            vec!["10", "10", "10", "10"],
-            vec!["traditional"],
-        ))
+        parse_inputs(&uu_app().get_matches_from(vec![
+            "od",
+            "--traditional",
+            "10",
+            "10",
+            "10",
+            "10",
+        ]))
         .unwrap_err();
     }
 
-    fn parse_offset_operand_str(s: &str) -> Result<usize, &'static str> {
+    fn parse_offset_operand_str(s: &str) -> Result<u64, &'static str> {
         parse_offset_operand(&String::from(s))
     }
 
diff --git a/src/uu/od/src/parse_nrofbytes.rs b/src/uu/od/src/parse_nrofbytes.rs
index d6329c60a..ad00452aa 100644
--- a/src/uu/od/src/parse_nrofbytes.rs
+++ b/src/uu/od/src/parse_nrofbytes.rs
@@ -1,6 +1,6 @@
 use uucore::parse_size::{parse_size, ParseSizeError};
 
-pub fn parse_number_of_bytes(s: &str) -> Result<usize, ParseSizeError> {
+pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
     let mut start = 0;
     let mut len = s.len();
     let mut radix = 16;
@@ -65,7 +65,7 @@ pub fn parse_number_of_bytes(s: &str) -> Result<usize, ParseSizeError> {
         _ => {}
     }
 
-    let factor = match usize::from_str_radix(&s[start..len], radix) {
+    let factor = match u64::from_str_radix(&s[start..len], radix) {
         Ok(f) => f,
         Err(e) => return Err(ParseSizeError::ParseFailure(e.to_string())),
     };
diff --git a/src/uu/od/src/partialreader.rs b/src/uu/od/src/partialreader.rs
index f155a7bd2..8b51d8dee 100644
--- a/src/uu/od/src/partialreader.rs
+++ b/src/uu/od/src/partialreader.rs
@@ -15,16 +15,16 @@ const MAX_SKIP_BUFFER: usize = 16 * 1024;
 /// number of bytes.
 pub struct PartialReader<R> {
     inner: R,
-    skip: usize,
-    limit: Option<usize>,
+    skip: u64,
+    limit: Option<u64>,
 }
 
 impl<R> PartialReader<R> {
     /// Create a new `PartialReader` wrapping `inner`, which will skip
     /// `skip` bytes, and limits the output to `limit` bytes. Set `limit`
     /// to `None` if there should be no limit.
-    pub fn new(inner: R, skip: usize, limit: Option<usize>) -> Self {
-        PartialReader { inner, skip, limit }
+    pub fn new(inner: R, skip: u64, limit: Option<u64>) -> Self {
+        Self { inner, skip, limit }
     }
 }
 
@@ -34,7 +34,7 @@ impl<R: Read> Read for PartialReader<R> {
             let mut bytes = [0; MAX_SKIP_BUFFER];
 
             while self.skip > 0 {
-                let skip_count = cmp::min(self.skip, MAX_SKIP_BUFFER);
+                let skip_count: usize = cmp::min(self.skip as usize, MAX_SKIP_BUFFER);
 
                 match self.inner.read(&mut bytes[..skip_count])? {
                     0 => {
@@ -44,7 +44,7 @@ impl<R: Read> Read for PartialReader<R> {
                             "tried to skip past end of input",
                         ));
                     }
-                    n => self.skip -= n,
+                    n => self.skip -= n as u64,
                 }
             }
         }
@@ -53,15 +53,15 @@ impl<R: Read> Read for PartialReader<R> {
             None => self.inner.read(out),
             Some(0) => Ok(0),
             Some(ref mut limit) => {
-                let slice = if *limit > out.len() {
+                let slice = if *limit > (out.len() as u64) {
                     out
                 } else {
-                    &mut out[0..*limit]
+                    &mut out[0..(*limit as usize)]
                 };
                 match self.inner.read(slice) {
                     Err(e) => Err(e),
                     Ok(r) => {
-                        *limit -= r;
+                        *limit -= r as u64;
                         Ok(r)
                     }
                 }
@@ -145,7 +145,11 @@ mod tests {
     fn test_read_skipping_huge_number() {
         let mut v = [0; 10];
         // test if it does not eat all memory....
-        let mut sut = PartialReader::new(Cursor::new(&b"abcdefgh"[..]), usize::max_value(), None);
+        let mut sut = PartialReader::new(
+            Cursor::new(&b"abcdefgh"[..]),
+            usize::max_value() as u64,
+            None,
+        );
 
         sut.read(v.as_mut()).unwrap_err();
     }
diff --git a/src/uu/od/src/peekreader.rs b/src/uu/od/src/peekreader.rs
index 73a94d2e2..45cd554d0 100644
--- a/src/uu/od/src/peekreader.rs
+++ b/src/uu/od/src/peekreader.rs
@@ -43,7 +43,7 @@ pub struct PeekReader<R> {
 impl<R> PeekReader<R> {
     /// Create a new `PeekReader` wrapping `inner`
     pub fn new(inner: R) -> Self {
-        PeekReader {
+        Self {
             inner,
             temp_buffer: Vec::new(),
         }
diff --git a/src/uu/paste/Cargo.toml b/src/uu/paste/Cargo.toml
index aeba6f68e..e741c1485 100644
--- a/src/uu/paste/Cargo.toml
+++ b/src/uu/paste/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_paste"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "paste ~ (uutils) merge lines from inputs"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/paste"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/paste"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/paste.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "paste"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/paste/LICENSE b/src/uu/paste/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/paste/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/paste/src/main.rs b/src/uu/paste/src/main.rs
index 1d4458b9e..00b99bc6b 100644
--- a/src/uu/paste/src/main.rs
+++ b/src/uu/paste/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_paste);
+uucore::bin!(uu_paste);
diff --git a/src/uu/paste/src/paste.rs b/src/uu/paste/src/paste.rs
index 9ac5507df..2826a19e3 100644
--- a/src/uu/paste/src/paste.rs
+++ b/src/uu/paste/src/paste.rs
@@ -7,14 +7,11 @@
 
 // spell-checker:ignore (ToDO) delim
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::File;
-use std::io::{stdin, BufRead, BufReader, Read};
-use std::iter::repeat;
+use std::io::{stdin, stdout, BufRead, BufReader, Read, Write};
 use std::path::Path;
+use uucore::error::{FromIo, UResult};
 
 static ABOUT: &str = "Write lines consisting of the sequentially corresponding lines from each
 FILE, separated by TABs, to standard output.";
@@ -36,120 +33,128 @@ fn read_line<R: Read>(
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().get_matches_from(args);
 
     let serial = matches.is_present(options::SERIAL);
-    let delimiters = matches.value_of(options::DELIMITER).unwrap().to_owned();
+    let delimiters = matches.value_of(options::DELIMITER).unwrap();
     let files = matches
         .values_of(options::FILE)
         .unwrap()
         .map(|s| s.to_owned())
         .collect();
-    paste(files, serial, delimiters);
-
-    0
+    paste(files, serial, delimiters)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::SERIAL)
+            Arg::new(options::SERIAL)
                 .long(options::SERIAL)
-                .short("s")
+                .short('s')
                 .help("paste one file at a time instead of in parallel"),
         )
         .arg(
-            Arg::with_name(options::DELIMITER)
+            Arg::new(options::DELIMITER)
                 .long(options::DELIMITER)
-                .short("d")
+                .short('d')
                 .help("reuse characters from LIST instead of TABs")
                 .value_name("LIST")
                 .default_value("\t")
                 .hide_default_value(true),
         )
         .arg(
-            Arg::with_name(options::FILE)
+            Arg::new(options::FILE)
                 .value_name("FILE")
-                .multiple(true)
+                .multiple_occurrences(true)
                 .default_value("-"),
         )
 }
 
-fn paste(filenames: Vec<String>, serial: bool, delimiters: String) {
-    let mut files: Vec<_> = filenames
-        .into_iter()
-        .map(|name| {
-            if name == "-" {
-                None
-            } else {
-                let r = crash_if_err!(1, File::open(Path::new(&name)));
-                Some(BufReader::new(r))
-            }
-        })
-        .collect();
+fn paste(filenames: Vec<String>, serial: bool, delimiters: &str) -> UResult<()> {
+    let mut files = Vec::with_capacity(filenames.len());
+    for name in filenames {
+        let file = if name == "-" {
+            None
+        } else {
+            let path = Path::new(&name);
+            let r = File::open(path).map_err_context(String::new)?;
+            Some(BufReader::new(r))
+        };
+        files.push(file);
+    }
 
-    let delimiters: Vec<String> = unescape(delimiters)
-        .chars()
-        .map(|x| x.to_string())
-        .collect();
+    let delimiters: Vec<char> = unescape(delimiters).chars().collect();
     let mut delim_count = 0;
+    let stdout = stdout();
+    let mut stdout = stdout.lock();
 
+    let mut output = String::new();
     if serial {
         for file in &mut files {
-            let mut output = String::new();
+            output.clear();
             loop {
-                let mut line = String::new();
-                match read_line(file.as_mut(), &mut line) {
+                match read_line(file.as_mut(), &mut output) {
                     Ok(0) => break,
                     Ok(_) => {
-                        output.push_str(line.trim_end());
-                        output.push_str(&delimiters[delim_count % delimiters.len()]);
+                        if output.ends_with('\n') {
+                            output.pop();
+                        }
+                        output.push(delimiters[delim_count % delimiters.len()]);
                     }
-                    Err(e) => crash!(1, "{}", e.to_string()),
+                    Err(e) => return Err(e.map_err_context(String::new)),
                 }
                 delim_count += 1;
             }
-            println!("{}", &output[..output.len() - 1]);
+            output.pop();
+            writeln!(stdout, "{}", output)?;
         }
     } else {
-        let mut eof: Vec<bool> = repeat(false).take(files.len()).collect();
+        let mut eof = vec![false; files.len()];
         loop {
-            let mut output = String::new();
+            output.clear();
             let mut eof_count = 0;
             for (i, file) in files.iter_mut().enumerate() {
                 if eof[i] {
                     eof_count += 1;
                 } else {
-                    let mut line = String::new();
-                    match read_line(file.as_mut(), &mut line) {
+                    match read_line(file.as_mut(), &mut output) {
                         Ok(0) => {
                             eof[i] = true;
                             eof_count += 1;
                         }
-                        Ok(_) => output.push_str(line.trim_end()),
-                        Err(e) => crash!(1, "{}", e.to_string()),
+                        Ok(_) => {
+                            if output.ends_with('\n') {
+                                output.pop();
+                            }
+                        }
+                        Err(e) => return Err(e.map_err_context(String::new)),
                     }
                 }
-                output.push_str(&delimiters[delim_count % delimiters.len()]);
+                output.push(delimiters[delim_count % delimiters.len()]);
                 delim_count += 1;
             }
             if files.len() == eof_count {
                 break;
             }
-            println!("{}", &output[..output.len() - 1]);
+            // Remove final delimiter
+            output.pop();
+            writeln!(stdout, "{}", output)?;
             delim_count = 0;
         }
     }
+    Ok(())
 }
 
 // Unescape all special characters
 // TODO: this will need work to conform to GNU implementation
-fn unescape(s: String) -> String {
+fn unescape(s: &str) -> String {
     s.replace("\\n", "\n")
         .replace("\\t", "\t")
         .replace("\\\\", "\\")
-        .replace("\\", "")
+        .replace('\\', "")
 }
diff --git a/src/uu/pathchk/Cargo.toml b/src/uu/pathchk/Cargo.toml
index 79e0c251b..88417a5a1 100644
--- a/src/uu/pathchk/Cargo.toml
+++ b/src/uu/pathchk/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_pathchk"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pathchk ~ (uutils) diagnose invalid or non-portable PATHNAME"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/pathchk"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pathchk"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/pathchk.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "pathchk"
diff --git a/src/uu/pathchk/LICENSE b/src/uu/pathchk/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/pathchk/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/pathchk/src/main.rs b/src/uu/pathchk/src/main.rs
index 2b7c3b3ee..6a2a0b945 100644
--- a/src/uu/pathchk/src/main.rs
+++ b/src/uu/pathchk/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_pathchk);
+uucore::bin!(uu_pathchk);
diff --git a/src/uu/pathchk/src/pathchk.rs b/src/uu/pathchk/src/pathchk.rs
index 8afeaff18..6260590aa 100644
--- a/src/uu/pathchk/src/pathchk.rs
+++ b/src/uu/pathchk/src/pathchk.rs
@@ -8,15 +8,12 @@
 //  * that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) lstat
-
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs;
 use std::io::{ErrorKind, Write};
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{set_exit_code, UResult, UUsageError};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 // operating mode
 enum Mode {
@@ -27,6 +24,7 @@ enum Mode {
 }
 
 static ABOUT: &str = "Check whether file names are valid or portable";
+const USAGE: &str = "{} [OPTION]... NAME...";
 
 mod options {
     pub const POSIX: &str = "posix";
@@ -39,17 +37,13 @@ mod options {
 const POSIX_PATH_MAX: usize = 256;
 const POSIX_NAME_MAX: usize = 14;
 
-fn usage() -> String {
-    format!("{0} [OPTION]... NAME...", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     // set working mode
     let is_posix = matches.values_of(options::POSIX).is_some();
@@ -68,56 +62,54 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     // take necessary actions
     let paths = matches.values_of(options::PATH);
-    let mut res = if paths.is_none() {
-        show_error!(
-            "missing operand\nTry '{} --help' for more information",
-            uucore::execution_phrase()
-        );
-        false
-    } else {
-        true
-    };
+    if paths.is_none() {
+        return Err(UUsageError::new(1, "missing operand"));
+    }
 
-    if res {
-        // free strings are path operands
-        // FIXME: TCS, seems inefficient and overly verbose (?)
-        for p in paths.unwrap() {
-            let mut path = Vec::new();
-            for path_segment in p.split('/') {
-                path.push(path_segment.to_string());
-            }
-            res &= check_path(&mode, &path);
+    // free strings are path operands
+    // FIXME: TCS, seems inefficient and overly verbose (?)
+    let mut res = true;
+    for p in paths.unwrap() {
+        let mut path = Vec::new();
+        for path_segment in p.split('/') {
+            path.push(path_segment.to_string());
         }
+        res &= check_path(&mode, &path);
     }
 
     // determine error code
-    if res {
-        0
-    } else {
-        1
+    if !res {
+        set_exit_code(1);
     }
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::POSIX)
-                .short("p")
+            Arg::new(options::POSIX)
+                .short('p')
                 .help("check for most POSIX systems"),
         )
         .arg(
-            Arg::with_name(options::POSIX_SPECIAL)
-                .short("P")
+            Arg::new(options::POSIX_SPECIAL)
+                .short('P')
                 .help(r#"check for empty names and leading "-""#),
         )
         .arg(
-            Arg::with_name(options::PORTABILITY)
+            Arg::new(options::PORTABILITY)
                 .long(options::PORTABILITY)
                 .help("check for all POSIX systems (equivalent to -p -P)"),
         )
-        .arg(Arg::with_name(options::PATH).hidden(true).multiple(true))
+        .arg(
+            Arg::new(options::PATH)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
 }
 
 // check a path, given as a slice of it's components and an operating mode
@@ -137,7 +129,7 @@ fn check_basic(path: &[String]) -> bool {
     // path length
     if total_len > POSIX_PATH_MAX {
         writeln!(
-            &mut std::io::stderr(),
+            std::io::stderr(),
             "limit {} exceeded by length {} of file name {}",
             POSIX_PATH_MAX,
             total_len,
@@ -145,7 +137,7 @@ fn check_basic(path: &[String]) -> bool {
         );
         return false;
     } else if total_len == 0 {
-        writeln!(&mut std::io::stderr(), "empty file name");
+        writeln!(std::io::stderr(), "empty file name");
         return false;
     }
     // components: character portability and length
@@ -153,7 +145,7 @@ fn check_basic(path: &[String]) -> bool {
         let component_len = p.len();
         if component_len > POSIX_NAME_MAX {
             writeln!(
-                &mut std::io::stderr(),
+                std::io::stderr(),
                 "limit {} exceeded by length {} of file name component {}",
                 POSIX_NAME_MAX,
                 component_len,
@@ -175,7 +167,7 @@ fn check_extra(path: &[String]) -> bool {
     for p in path {
         if p.starts_with('-') {
             writeln!(
-                &mut std::io::stderr(),
+                std::io::stderr(),
                 "leading hyphen in file name component {}",
                 p.quote()
             );
@@ -184,7 +176,7 @@ fn check_extra(path: &[String]) -> bool {
     }
     // path length
     if path.join("/").is_empty() {
-        writeln!(&mut std::io::stderr(), "empty file name");
+        writeln!(std::io::stderr(), "empty file name");
         return false;
     }
     true
@@ -197,7 +189,7 @@ fn check_default(path: &[String]) -> bool {
     // path length
     if total_len > libc::PATH_MAX as usize {
         writeln!(
-            &mut std::io::stderr(),
+            std::io::stderr(),
             "limit {} exceeded by length {} of file name {}",
             libc::PATH_MAX,
             total_len,
@@ -210,7 +202,7 @@ fn check_default(path: &[String]) -> bool {
         let component_len = p.len();
         if component_len > libc::FILENAME_MAX as usize {
             writeln!(
-                &mut std::io::stderr(),
+                std::io::stderr(),
                 "limit {} exceeded by length {} of file name component {}",
                 libc::FILENAME_MAX,
                 component_len,
@@ -232,7 +224,7 @@ fn check_searchable(path: &str) -> bool {
             if e.kind() == ErrorKind::NotFound {
                 true
             } else {
-                writeln!(&mut std::io::stderr(), "{}", e);
+                writeln!(std::io::stderr(), "{}", e);
                 false
             }
         }
@@ -246,7 +238,7 @@ fn check_portable_chars(path_segment: &str) -> bool {
         if !VALID_CHARS.contains(ch) {
             let invalid = path_segment[i..].chars().next().unwrap();
             writeln!(
-                &mut std::io::stderr(),
+                std::io::stderr(),
                 "nonportable character '{}' in file name component {}",
                 invalid,
                 path_segment.quote()
diff --git a/src/uu/pinky/Cargo.toml b/src/uu/pinky/Cargo.toml
index 297d40642..a4562562f 100644
--- a/src/uu/pinky/Cargo.toml
+++ b/src/uu/pinky/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_pinky"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pinky ~ (uutils) display user information"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/pinky"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pinky"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/pinky.rs"
 
 [dependencies]
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["utmpx", "entries"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["utmpx", "entries"] }
 
 [[bin]]
 name = "pinky"
diff --git a/src/uu/pinky/LICENSE b/src/uu/pinky/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/pinky/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/pinky/src/main.rs b/src/uu/pinky/src/main.rs
index 5414c42cc..8826e60a0 100644
--- a/src/uu/pinky/src/main.rs
+++ b/src/uu/pinky/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_pinky);
+uucore::bin!(uu_pinky);
diff --git a/src/uu/pinky/src/pinky.rs b/src/uu/pinky/src/pinky.rs
index 4aa27affa..437c20cf5 100644
--- a/src/uu/pinky/src/pinky.rs
+++ b/src/uu/pinky/src/pinky.rs
@@ -7,9 +7,8 @@
 
 // spell-checker:ignore (ToDO) BUFSIZE gecos fullname, mesg iobuf
 
-#[macro_use]
-extern crate uucore;
 use uucore::entries::{Locate, Passwd};
+use uucore::error::{FromIo, UResult};
 use uucore::libc::S_IWGRP;
 use uucore::utmpx::{self, time, Utmpx};
 
@@ -19,13 +18,12 @@ use std::io::BufReader;
 use std::fs::File;
 use std::os::unix::fs::MetadataExt;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::path::PathBuf;
-use uucore::InvalidEncodingHandling;
-
-const BUFSIZE: usize = 1024;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "pinky - lightweight finger";
+const USAGE: &str = "{} [OPTION]... [USER]...";
 
 mod options {
     pub const LONG_FORMAT: &str = "long_format";
@@ -38,10 +36,7 @@ mod options {
     pub const OMIT_NAME_HOST: &str = "omit_name_host";
     pub const OMIT_NAME_HOST_TIME: &str = "omit_name_host_time";
     pub const USER: &str = "user";
-}
-
-fn usage() -> String {
-    format!("{0} [OPTION]... [USER]...", uucore::execution_phrase())
+    pub const HELP: &str = "help";
 }
 
 fn get_long_usage() -> String {
@@ -52,18 +47,15 @@ fn get_long_usage() -> String {
     )
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
-    let usage = usage();
     let after_help = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let users: Vec<String> = matches
         .values_of(options::USER)
@@ -122,67 +114,79 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     };
 
     if do_short_format {
-        pk.short_pinky();
-        0
+        match pk.short_pinky() {
+            Ok(_) => Ok(()),
+            Err(e) => Err(e.map_err_context(String::new)),
+        }
     } else {
-        pk.long_pinky()
+        pk.long_pinky();
+        Ok(())
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::LONG_FORMAT)
-                .short("l")
+            Arg::new(options::LONG_FORMAT)
+                .short('l')
                 .requires(options::USER)
                 .help("produce long format output for the specified USERs"),
         )
         .arg(
-            Arg::with_name(options::OMIT_HOME_DIR)
-                .short("b")
+            Arg::new(options::OMIT_HOME_DIR)
+                .short('b')
                 .help("omit the user's home directory and shell in long format"),
         )
         .arg(
-            Arg::with_name(options::OMIT_PROJECT_FILE)
-                .short("h")
+            Arg::new(options::OMIT_PROJECT_FILE)
+                .short('h')
                 .help("omit the user's project file in long format"),
         )
         .arg(
-            Arg::with_name(options::OMIT_PLAN_FILE)
-                .short("p")
+            Arg::new(options::OMIT_PLAN_FILE)
+                .short('p')
                 .help("omit the user's plan file in long format"),
         )
         .arg(
-            Arg::with_name(options::SHORT_FORMAT)
-                .short("s")
+            Arg::new(options::SHORT_FORMAT)
+                .short('s')
                 .help("do short format output, this is the default"),
         )
         .arg(
-            Arg::with_name(options::OMIT_HEADINGS)
-                .short("f")
+            Arg::new(options::OMIT_HEADINGS)
+                .short('f')
                 .help("omit the line of column headings in short format"),
         )
         .arg(
-            Arg::with_name(options::OMIT_NAME)
-                .short("w")
+            Arg::new(options::OMIT_NAME)
+                .short('w')
                 .help("omit the user's full name in short format"),
         )
         .arg(
-            Arg::with_name(options::OMIT_NAME_HOST)
-                .short("i")
+            Arg::new(options::OMIT_NAME_HOST)
+                .short('i')
                 .help("omit the user's full name and remote host in short format"),
         )
         .arg(
-            Arg::with_name(options::OMIT_NAME_HOST_TIME)
-                .short("q")
+            Arg::new(options::OMIT_NAME_HOST_TIME)
+                .short('q')
                 .help("omit the user's full name, remote host and idle time in short format"),
         )
         .arg(
-            Arg::with_name(options::USER)
+            Arg::new(options::USER)
                 .takes_value(true)
-                .multiple(true),
+                .multiple_occurrences(true),
+        )
+        .arg(
+            // Redefine the help argument to not include the short flag
+            // since that conflicts with omit_project_file.
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information"),
         )
 }
 
@@ -206,9 +210,9 @@ impl Capitalize for str {
         self.char_indices()
             .fold(String::with_capacity(self.len()), |mut acc, x| {
                 if x.0 != 0 {
-                    acc.push(x.1)
+                    acc.push(x.1);
                 } else {
-                    acc.push(x.1.to_ascii_uppercase())
+                    acc.push(x.1.to_ascii_uppercase());
                 }
                 acc
             })
@@ -241,8 +245,16 @@ fn time_string(ut: &Utmpx) -> String {
     time::strftime("%b %e %H:%M", &ut.login_time()).unwrap() // LC_ALL=C
 }
 
+fn gecos_to_fullname(pw: &Passwd) -> String {
+    let mut gecos = pw.user_info.clone();
+    if let Some(n) = gecos.find(',') {
+        gecos.truncate(n);
+    }
+    gecos.replace('&', &pw.name.capitalize())
+}
+
 impl Pinky {
-    fn print_entry(&self, ut: &Utmpx) {
+    fn print_entry(&self, ut: &Utmpx) -> std::io::Result<()> {
         let mut pts_path = PathBuf::from("/dev");
         pts_path.push(ut.tty_device().as_str());
 
@@ -267,11 +279,7 @@ impl Pinky {
 
         if self.include_fullname {
             if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
-                let mut gecos = pw.user_info().into_owned();
-                if let Some(n) = gecos.find(',') {
-                    gecos.truncate(n + 1);
-                }
-                print!(" {:<19.19}", gecos.replace("&", &pw.name().capitalize()));
+                print!(" {:<19.19}", gecos_to_fullname(&pw));
             } else {
                 print!(" {:19}", "        ???");
             }
@@ -291,11 +299,12 @@ impl Pinky {
 
         let mut s = ut.host();
         if self.include_where && !s.is_empty() {
-            s = crash_if_err!(1, ut.canon_host());
+            s = ut.canon_host()?;
             print!(" {}", s);
         }
 
         println!();
+        Ok(())
     }
 
     fn print_heading(&self) {
@@ -314,32 +323,31 @@ impl Pinky {
         println!();
     }
 
-    fn short_pinky(&self) {
+    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() {
-                if self.names.is_empty() {
-                    self.print_entry(&ut)
-                } else if self.names.iter().any(|n| n.as_str() == ut.user()) {
-                    self.print_entry(&ut);
-                }
+            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) -> i32 {
+    fn long_pinky(&self) {
         for u in &self.names {
             print!("Login name: {:<28}In real life: ", u);
             if let Ok(pw) = Passwd::locate(u.as_str()) {
-                println!(" {}", pw.user_info().replace("&", &pw.name().capitalize()));
+                println!(" {}", gecos_to_fullname(&pw));
                 if self.include_home_and_shell {
-                    print!("Directory: {:<29}", pw.user_dir());
-                    println!("Shell:  {}", pw.user_shell());
+                    print!("Directory: {:<29}", pw.user_dir);
+                    println!("Shell:  {}", pw.user_shell);
                 }
                 if self.include_project {
-                    let mut p = PathBuf::from(pw.user_dir().as_ref());
+                    let mut p = PathBuf::from(&pw.user_dir);
                     p.push(".project");
                     if let Ok(f) = File::open(p) {
                         print!("Project: ");
@@ -347,7 +355,7 @@ impl Pinky {
                     }
                 }
                 if self.include_plan {
-                    let mut p = PathBuf::from(pw.user_dir().as_ref());
+                    let mut p = PathBuf::from(&pw.user_dir);
                     p.push(".plan");
                     if let Ok(f) = File::open(p) {
                         println!("Plan:");
@@ -359,18 +367,13 @@ impl Pinky {
                 println!(" ???");
             }
         }
-        0
     }
 }
 
 fn read_to_console<F: Read>(f: F) {
     let mut reader = BufReader::new(f);
-    let mut iobuf = [0_u8; BUFSIZE];
-    while let Ok(n) = reader.read(&mut iobuf) {
-        if n == 0 {
-            break;
-        }
-        let s = String::from_utf8_lossy(&iobuf);
-        print!("{}", s);
+    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 499ee7726..7ed902cb0 100644
--- a/src/uu/pr/Cargo.toml
+++ b/src/uu/pr/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_pr"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pr ~ (uutils) convert text files for printing"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/pr"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pr"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,19 +15,13 @@ edition = "2018"
 path = "src/pr.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 uucore = { version=">=0.0.7", package="uucore", path="../../uucore", features=["entries"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-getopts = "0.2.21"
 chrono = "0.4.19"
 quick-error = "2.0.1"
-itertools = "0.10"
+itertools = "0.10.0"
 regex = "1.0"
 
 [[bin]]
 name = "pr"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/pr/LICENSE b/src/uu/pr/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/pr/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/pr/src/main.rs b/src/uu/pr/src/main.rs
index 893145c3e..faa7a8114 100644
--- a/src/uu/pr/src/main.rs
+++ b/src/uu/pr/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_pr); // spell-checker:ignore procs uucore
+uucore::bin!(uu_pr); // spell-checker:ignore procs uucore
diff --git a/src/uu/pr/src/pr.rs b/src/uu/pr/src/pr.rs
index 0886a9991..e18d29730 100644
--- a/src/uu/pr/src/pr.rs
+++ b/src/uu/pr/src/pr.rs
@@ -1,5 +1,3 @@
-#![crate_name = "uu_pr"]
-
 // This file is part of the uutils coreutils package.
 //
 // For the full copyright and license information, please view the LICENSE file
@@ -13,8 +11,7 @@ extern crate quick_error;
 
 use chrono::offset::Local;
 use chrono::DateTime;
-use getopts::Matches;
-use getopts::{HasArg, Occur};
+use clap::{AppSettings, Arg, ArgMatches, Command};
 use itertools::Itertools;
 use quick_error::ResultExt;
 use regex::Regex;
@@ -25,11 +22,35 @@ use std::io::{stdin, stdout, BufRead, BufReader, Lines, Read, Write};
 use std::os::unix::fs::FileTypeExt;
 
 use uucore::display::Quotable;
+use uucore::error::{set_exit_code, UResult};
 
-type IOError = std::io::Error;
-
-const NAME: &str = "pr";
 const VERSION: &str = env!("CARGO_PKG_VERSION");
+const ABOUT: &str =
+    "Write content of given file or standard input to standard output with pagination filter";
+const AFTER_HELP: &str =
+    "    +PAGE\n            Begin output at page number page of the formatted input.
+    -COLUMN\n            Produce multi-column output. See --column
+
+The pr utility is a printing and pagination filter
+for text files.  When multiple input files are specified,
+each is read, formatted, and written to standard
+output.  By default, the input is separated
+into 66-line pages, each with
+
+o   A 5-line header with the page number, date,
+    time, and the pathname of the file.
+
+o   A 5-line trailer consisting of blank lines.
+
+If standard output is associated with a terminal,
+diagnostic messages are suppressed until the pr
+utility has completed processing.
+
+When multiple column output is specified, text columns
+are of equal width.  By default text columns
+are separated by at least one <blank>.  Input lines
+that do not fit into a text column are truncated.
+Lines are not truncated under single column output.";
 const TAB: char = '\t';
 const LINES_PER_PAGE: usize = 66;
 const LINES_PER_PAGE_FOR_FORM_FEED: usize = 63;
@@ -43,25 +64,27 @@ const DEFAULT_COLUMN_SEPARATOR: &char = &TAB;
 const FF: u8 = 0x0C_u8;
 
 mod options {
-    pub const STRING_HEADER_OPTION: &str = "h";
-    pub const DOUBLE_SPACE_OPTION: &str = "d";
-    pub const NUMBERING_MODE_OPTION: &str = "n";
-    pub const FIRST_LINE_NUMBER_OPTION: &str = "N";
-    pub const PAGE_RANGE_OPTION: &str = "pages";
-    pub const NO_HEADER_TRAILER_OPTION: &str = "t";
-    pub const PAGE_LENGTH_OPTION: &str = "l";
-    pub const SUPPRESS_PRINTING_ERROR: &str = "r";
-    pub const FORM_FEED_OPTION: &str = "F";
-    pub const FORM_FEED_OPTION_SMALL: &str = "f";
-    pub const COLUMN_WIDTH_OPTION: &str = "w";
-    pub const PAGE_WIDTH_OPTION: &str = "W";
-    pub const ACROSS_OPTION: &str = "a";
-    pub const COLUMN_OPTION: &str = "column";
-    pub const COLUMN_CHAR_SEPARATOR_OPTION: &str = "s";
-    pub const COLUMN_STRING_SEPARATOR_OPTION: &str = "S";
-    pub const MERGE_FILES_PRINT: &str = "m";
-    pub const OFFSET_SPACES_OPTION: &str = "o";
-    pub const JOIN_LINES_OPTION: &str = "J";
+    pub const HEADER: &str = "header";
+    pub const DOUBLE_SPACE: &str = "double-space";
+    pub const NUMBER_LINES: &str = "number-lines";
+    pub const FIRST_LINE_NUMBER: &str = "first-line-number";
+    pub const PAGES: &str = "pages";
+    pub const OMIT_HEADER: &str = "omit-header";
+    pub const PAGE_LENGTH: &str = "length";
+    pub const NO_FILE_WARNINGS: &str = "no-file-warnings";
+    pub const FORM_FEED: &str = "form-feed";
+    pub const COLUMN_WIDTH: &str = "width";
+    pub const PAGE_WIDTH: &str = "page-width";
+    pub const ACROSS: &str = "across";
+    pub const COLUMN: &str = "column";
+    pub const COLUMN_CHAR_SEPARATOR: &str = "separator";
+    pub const COLUMN_STRING_SEPARATOR: &str = "sep-string";
+    pub const MERGE: &str = "merge";
+    pub const INDENT: &str = "indent";
+    pub const JOIN_LINES: &str = "join-lines";
+    pub const HELP: &str = "help";
+    pub const VERSION: &str = "version";
+    pub const FILES: &str = "files";
 }
 
 struct OutputOptions {
@@ -91,7 +114,7 @@ struct FileLine {
     line_number: usize,
     page_number: usize,
     group_key: usize,
-    line_content: Result<String, IOError>,
+    line_content: Result<String, std::io::Error>,
     form_feeds_after: usize,
 }
 
@@ -110,8 +133,8 @@ struct NumberingMode {
 }
 
 impl Default for NumberingMode {
-    fn default() -> NumberingMode {
-        NumberingMode {
+    fn default() -> Self {
+        Self {
             width: 5,
             separator: TAB.to_string(),
             first_number: 1,
@@ -120,8 +143,8 @@ impl Default for NumberingMode {
 }
 
 impl Default for FileLine {
-    fn default() -> FileLine {
-        FileLine {
+    fn default() -> Self {
+        Self {
             file_id: 0,
             line_number: 0,
             page_number: 0,
@@ -132,17 +155,17 @@ impl Default for FileLine {
     }
 }
 
-impl From<IOError> for PrError {
-    fn from(err: IOError) -> Self {
-        PrError::EncounteredErrors(err.to_string())
+impl From<std::io::Error> for PrError {
+    fn from(err: std::io::Error) -> Self {
+        Self::EncounteredErrors(err.to_string())
     }
 }
 
 quick_error! {
     #[derive(Debug)]
     enum PrError {
-        Input(err: IOError, path: String) {
-            context(path: &'a str, err: IOError) -> (err, path.to_owned())
+        Input(err: std::io::Error, path: String) {
+            context(path: &'a str, err: std::io::Error) -> (err, path.to_owned())
             display("pr: Reading from input {0} gave error", path)
             source(err)
         }
@@ -169,250 +192,239 @@ quick_error! {
     }
 }
 
-pub fn uu_app() -> clap::App<'static, 'static> {
-    // TODO: migrate to clap to get more shell completions
-    clap::App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .version(VERSION)
+        .about(ABOUT)
+        .after_help(AFTER_HELP)
+        .infer_long_args(true)
+        .args_override_self(true)
+        .setting(AppSettings::NoAutoHelp)
+        .setting(AppSettings::NoAutoVersion)
+        .arg(
+            Arg::new(options::PAGES)
+                .long(options::PAGES)
+                .help("Begin and stop printing with page FIRST_PAGE[:LAST_PAGE]")
+                .takes_value(true)
+                .value_name("FIRST_PAGE[:LAST_PAGE]"),
+        )
+        .arg(
+            Arg::new(options::HEADER)
+                .short('h')
+                .long(options::HEADER)
+                .help(
+                    "Use the string header to replace the file name \
+                    in the header line.",
+                )
+                .takes_value(true)
+                .value_name("STRING"),
+        )
+        .arg(
+            Arg::new(options::DOUBLE_SPACE)
+                .short('d')
+                .long(options::DOUBLE_SPACE)
+                .help("Produce output that is double spaced. An extra <newline> character is output following every <newline>
+                found in the input.")
+        )
+        .arg(
+            Arg::new(options::NUMBER_LINES)
+                .short('n')
+                .long(options::NUMBER_LINES)
+                .help("Provide width digit line numbering.  The default for width, if not specified, is 5.  The number occupies
+                the first width column positions of each text column or each line of -m output.  If char (any non-digit
+                character) is given, it is appended to the line number to separate it from whatever follows.  The default
+                for char is a <tab>.  Line numbers longer than width columns are truncated.")
+                .takes_value(true)
+                .allow_hyphen_values(true)
+                .value_name("[char][width]")
+        )
+        .arg(
+            Arg::new(options::FIRST_LINE_NUMBER)
+                .short('N')
+                .long(options::FIRST_LINE_NUMBER)
+                .help("start counting with NUMBER at 1st line of first page printed")
+                .takes_value(true)
+                .value_name("NUMBER")
+        )
+        .arg(
+            Arg::new(options::OMIT_HEADER)
+                .short('t')
+                .long(options::OMIT_HEADER)
+                .help("Write neither the five-line identifying header nor the five-line trailer usually supplied for  each  page.  Quit
+                writing after the last line of each file without spacing to the end of the page.")
+        )
+        .arg(
+            Arg::new(options::PAGE_LENGTH)
+                .short('l')
+                .long(options::PAGE_LENGTH)
+                .help("Override the 66-line default (default number of lines of text 56, and with -F 63) and reset the page length to lines.  If lines is not greater than the sum  of  both
+                the  header  and trailer depths (in lines), the pr utility shall suppress both the header and trailer, as if the
+                -t option were in effect. ")
+                .takes_value(true)
+                .value_name("PAGE_LENGTH")
+        )
+        .arg(
+            Arg::new(options::NO_FILE_WARNINGS)
+                .short('r')
+                .long(options::NO_FILE_WARNINGS)
+                .help("omit warning when a file cannot be opened")
+        )
+        .arg(
+            Arg::new(options::FORM_FEED)
+                .short('F')
+                .short_alias('f')
+                .long(options::FORM_FEED)
+                .help("Use a <form-feed> for new pages, instead of the default behavior that uses a sequence of <newline>s.")
+        )
+        .arg(
+            Arg::new(options::COLUMN_WIDTH)
+                .short('w')
+                .long(options::COLUMN_WIDTH)
+                .help("Set the width of the line to width column positions for multiple text-column output only. If the -w option is
+                not specified and the -s option is not specified, the default width shall be 72. If the -w option is not specified
+                and the -s option is specified, the default width shall be 512.")
+                .takes_value(true)
+                .value_name("width")
+        )
+        .arg(
+            Arg::new(options::PAGE_WIDTH)
+                .short('W')
+                .long(options::PAGE_WIDTH)
+                .help("set page width to PAGE_WIDTH (72) characters always,
+                truncate lines, except -J option is set, no interference
+                with -S or -s")
+                .takes_value(true)
+                .value_name("width")
+        )
+        .arg(
+            Arg::new(options::ACROSS)
+                .short('a')
+                .long(options::ACROSS)
+                .help("Modify the effect of the - column option so that the columns are filled across the page in a  round-robin  order
+                (for example, when column is 2, the first input line heads column 1, the second heads column 2, the third is the
+                second line in column 1, and so on).")
+        )
+        .arg(
+            Arg::new(options::COLUMN)
+                .long(options::COLUMN)
+                .help("Produce multi-column output that is arranged in column columns (the default shall be 1) and is written down each
+                column  in  the order in which the text is received from the input file. This option should not be used with -m.
+                The options -e and -i shall be assumed for multiple text-column output.  Whether or not text columns are produced
+                with identical vertical lengths is unspecified, but a text column shall never exceed the length of the
+                page (see the -l option). When used with -t, use the minimum number of lines to write the output.")
+                .takes_value(true)
+                .value_name("column")
+        )
+        .arg(
+            Arg::new(options::COLUMN_CHAR_SEPARATOR)
+                .short('s')
+                .long(options::COLUMN_CHAR_SEPARATOR)
+                .help("Separate text columns by the single character char instead of by the appropriate number of <space>s
+                (default for char is the <tab> character).")
+                .takes_value(true)
+                .value_name("char")
+        )
+        .arg(
+            Arg::new(options::COLUMN_STRING_SEPARATOR)
+                .short('S')
+                .long(options::COLUMN_STRING_SEPARATOR)
+                .help("separate columns by STRING,
+                without -S: Default separator <TAB> with -J and <space>
+                otherwise (same as -S\" \"), no effect on column options")
+                .takes_value(true)
+                .value_name("string")
+        )
+        .arg(
+            Arg::new(options::MERGE)
+                .short('m')
+                .long(options::MERGE)
+                .help("Merge files. Standard output shall be formatted so the pr utility writes one line from each file specified by  a
+                file  operand, side by side into text columns of equal fixed widths, in terms of the number of column positions.
+                Implementations shall support merging of at least nine file operands.")
+        )
+        .arg(
+            Arg::new(options::INDENT)
+                .short('o')
+                .long(options::INDENT)
+                .help("Each line of output shall be preceded by offset <space>s. If the -o option is not specified, the default offset
+                shall be zero. The space taken is in addition to the output line width (see the -w option below).")
+                .takes_value(true)
+                .value_name("margin")
+        )
+        .arg(
+            Arg::new(options::JOIN_LINES)
+                .short('J')
+                .help("merge full lines, turns off -W line truncation, no column
+                alignment, --sep-string[=STRING] sets separators")
+        )
+        .arg(
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Show this help message")
+        )
+        .arg(
+            Arg::new(options::VERSION)
+                .short('V')
+                .long(options::VERSION)
+                .help("Show version information")
+        )
+        .arg(
+            Arg::new(options::FILES)
+                .multiple_occurrences(true)
+                .multiple_values(true)
+        )
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(uucore::InvalidEncodingHandling::Ignore)
         .accept_any();
-    let mut opts = getopts::Options::new();
-
-    opts.opt(
-        "",
-        options::PAGE_RANGE_OPTION,
-        "Begin and stop printing with page FIRST_PAGE[:LAST_PAGE]",
-        "FIRST_PAGE[:LAST_PAGE]",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::STRING_HEADER_OPTION,
-        "header",
-        "Use the string header to replace the file name \
-         in the header line.",
-        "STRING",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::DOUBLE_SPACE_OPTION,
-        "double-space",
-        "Produce output that is double spaced. An extra <newline> character is output following every <newline>
-           found in the input.",
-        "",
-        HasArg::No,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::NUMBERING_MODE_OPTION,
-        "number-lines",
-        "Provide width digit line numbering.  The default for width, if not specified, is 5.  The number occupies
-           the first width column positions of each text column or each line of -m output.  If char (any non-digit
-           character) is given, it is appended to the line number to separate it from whatever follows.  The default
-           for char is a <tab>.  Line numbers longer than width columns are truncated.",
-        "[char][width]",
-        HasArg::Maybe,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::FIRST_LINE_NUMBER_OPTION,
-        "first-line-number",
-        "start counting with NUMBER at 1st line of first page printed",
-        "NUMBER",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::NO_HEADER_TRAILER_OPTION,
-        "omit-header",
-        "Write neither the five-line identifying header nor the five-line trailer usually supplied for  each  page.  Quit
-              writing after the last line of each file without spacing to the end of the page.",
-        "",
-        HasArg::No,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::PAGE_LENGTH_OPTION,
-        "length",
-        "Override the 66-line default (default number of lines of text 56, and with -F 63) and reset the page length to lines.  If lines is not greater than the sum  of  both
-              the  header  and trailer depths (in lines), the pr utility shall suppress both the header and trailer, as if the
-              -t option were in effect. ",
-        "lines",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::SUPPRESS_PRINTING_ERROR,
-        "no-file-warnings",
-        "omit warning when a file cannot be opened",
-        "",
-        HasArg::No,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::FORM_FEED_OPTION,
-        "form-feed",
-        "Use a <form-feed> for new pages, instead of the default behavior that uses a sequence of <newline>s.",
-        "",
-        HasArg::No,
-        Occur::Optional,
-    );
-    opts.opt(
-        options::FORM_FEED_OPTION_SMALL,
-        "form-feed",
-        "Same as -F but pause before beginning the first page if standard output is a
-           terminal.",
-        "",
-        HasArg::No,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        "",
-        options::COLUMN_OPTION,
-        "Produce multi-column output that is arranged in column columns (the default shall be 1) and is written down each
-              column  in  the order in which the text is received from the input file. This option should not be used with -m.
-              The options -e and -i shall be assumed for multiple text-column output.  Whether or not text columns are produced
-              with identical vertical lengths is unspecified, but a text column shall never exceed the length of the
-              page (see the -l option). When used with -t, use the minimum number of lines to write the output.",
-        "[column]",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::COLUMN_WIDTH_OPTION,
-        "width",
-        "Set the width of the line to width column positions for multiple text-column output only. If the -w option is
-              not specified and the -s option is not specified, the default width shall be 72. If the -w option is not specified
-              and the -s option is specified, the default width shall be 512.",
-        "[width]",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::PAGE_WIDTH_OPTION,
-        "page-width",
-        "set page width to PAGE_WIDTH (72) characters always,
-        truncate lines, except -J option is set, no interference
-        with -S or -s",
-        "[width]",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::ACROSS_OPTION,
-        "across",
-        "Modify the effect of the - column option so that the columns are filled across the page in a  round-robin  order
-              (for example, when column is 2, the first input line heads column 1, the second heads column 2, the third is the
-              second line in column 1, and so on).",
-        "",
-        HasArg::No,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::COLUMN_CHAR_SEPARATOR_OPTION,
-        "separator",
-        "Separate text columns by the single character char instead of by the appropriate number of <space>s
-           (default for char is the <tab> character).",
-        "char",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::COLUMN_STRING_SEPARATOR_OPTION,
-        "sep-string",
-        "separate columns by STRING,
-        without -S: Default separator <TAB> with -J and <space>
-        otherwise (same as -S\" \"), no effect on column options",
-        "string",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::MERGE_FILES_PRINT,
-        "merge",
-        "Merge files. Standard output shall be formatted so the pr utility writes one line from each file specified by  a
-              file  operand, side by side into text columns of equal fixed widths, in terms of the number of column positions.
-              Implementations shall support merging of at least nine file operands.",
-        "",
-        HasArg::No,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::OFFSET_SPACES_OPTION,
-        "indent",
-        "Each  line of output shall be preceded by offset <space>s. If the -o option is not specified, the default offset
-              shall be zero. The space taken is in addition to the output line width (see the -w option below).",
-        "offset",
-        HasArg::Yes,
-        Occur::Optional,
-    );
-
-    opts.opt(
-        options::JOIN_LINES_OPTION,
-        "join-lines",
-        "merge full lines, turns off -W line truncation, no column
-    alignment, --sep-string[=STRING] sets separators",
-        "offset",
-        HasArg::No,
-        Occur::Optional,
-    );
-
-    opts.optflag("", "help", "display this help and exit");
-    opts.optflag("V", "version", "output version information and exit");
 
     let opt_args = recreate_arguments(&args);
 
-    let matches = match opts.parse(&opt_args[1..]) {
+    let mut command = uu_app();
+    let matches = match command.try_get_matches_from_mut(opt_args) {
         Ok(m) => m,
-        Err(e) => panic!("Invalid options\n{}", e),
+        Err(e) => {
+            e.print()?;
+            set_exit_code(1);
+            return Ok(());
+        }
     };
 
-    if matches.opt_present("version") {
-        println!("{} {}", NAME, VERSION);
-        return 0;
+    if matches.is_present(options::VERSION) {
+        println!("{}", command.render_long_version());
+        return Ok(());
     }
 
-    let mut files = matches.free.clone();
+    if matches.is_present(options::HELP) {
+        command.print_long_help()?;
+        return Ok(());
+    }
+
+    let mut files = matches
+        .values_of(options::FILES)
+        .map(|v| v.collect::<Vec<_>>())
+        .unwrap_or_default()
+        .clone();
     if files.is_empty() {
-        files.insert(0, FILE_STDIN.to_owned());
+        files.insert(0, FILE_STDIN);
     }
 
-    if matches.opt_present("help") {
-        return print_usage(&mut opts, &matches);
-    }
-
-    let file_groups: Vec<_> = if matches.opt_present(options::MERGE_FILES_PRINT) {
+    let file_groups: Vec<_> = if matches.is_present(options::MERGE) {
         vec![files]
     } else {
         files.into_iter().map(|i| vec![i]).collect()
     };
 
     for file_group in file_groups {
-        let result_options = build_options(&matches, &file_group, args.join(" "));
+        let result_options = build_options(&matches, &file_group, &args.join(" "));
         let options = match result_options {
             Ok(options) => options,
             Err(err) => {
-                print_error(&matches, err);
-                return 1;
+                print_error(&matches, &err);
+                return Err(1.into());
             }
         };
 
@@ -424,17 +436,16 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
         let status = match cmd_result {
             Err(error) => {
-                print_error(&matches, error);
+                print_error(&matches, &error);
                 1
             }
             _ => 0,
         };
         if status != 0 {
-            return status;
+            return Err(status.into());
         }
     }
-
-    0
+    Ok(())
 }
 
 /// Returns re-written arguments which are passed to the program.
@@ -443,7 +454,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 /// * `args` - Command line arguments
 fn recreate_arguments(args: &[String]) -> Vec<String> {
     let column_page_option = Regex::new(r"^[-+]\d+.*").unwrap();
-    let num_regex = Regex::new(r"(.\d+)|(\d+)|^[^-]$").unwrap();
+    let num_regex = Regex::new(r"^[^-]\d*$").unwrap();
     //let a_file: Regex = Regex::new(r"^[^-+].*").unwrap();
     let n_regex = Regex::new(r"^-n\s*$").unwrap();
     let mut arguments = args.to_owned();
@@ -464,57 +475,13 @@ fn recreate_arguments(args: &[String]) -> Vec<String> {
         .collect()
 }
 
-fn print_error(matches: &Matches, err: PrError) {
-    if !matches.opt_present(options::SUPPRESS_PRINTING_ERROR) {
+fn print_error(matches: &ArgMatches, err: &PrError) {
+    if !matches.is_present(options::NO_FILE_WARNINGS) {
         eprintln!("{}", err);
     }
 }
 
-fn print_usage(opts: &mut getopts::Options, matches: &Matches) -> i32 {
-    println!("{} {} -- print files", NAME, VERSION);
-    println!();
-    println!(
-        "Usage: {} [+page] [-column] [-adFfmprt] [[-e] [char] [gap]]
-        [-L locale] [-h header] [[-i] [char] [gap]]
-        [-l lines] [-o offset] [[-s] [char]] [[-n] [char]
-        [width]] [-w width] [-] [file ...].",
-        NAME
-    );
-    println!();
-    let usage: &str = "The pr utility is a printing and pagination filter
-     for text files.  When multiple input files are specified,
-     each is read, formatted, and written to standard
-     output.  By default, the input is separated
-     into 66-line pages, each with
-
-     o   A 5-line header with the page number, date,
-         time, and the pathname of the file.
-
-     o   A 5-line trailer consisting of blank lines.
-
-     If standard output is associated with a terminal,
-     diagnostic messages are suppressed until the pr
-     utility has completed processing.
-
-     When multiple column output is specified, text columns
-     are of equal width.  By default text columns
-     are separated by at least one <blank>.  Input lines
-     that do not fit into a text column are truncated.
-     Lines are not truncated under single column output.";
-    println!("{}", opts.usage(usage));
-    println!("    +page \t\tBegin output at page number page of the formatted input.");
-    println!(
-        "    -column \t\tProduce multi-column output. Refer --{}",
-        options::COLUMN_OPTION
-    );
-    if matches.free.is_empty() {
-        return 1;
-    }
-
-    0
-}
-
-fn parse_usize(matches: &Matches, opt: &str) -> Option<Result<usize, PrError>> {
+fn parse_usize(matches: &ArgMatches, opt: &str) -> Option<Result<usize, PrError>> {
     let from_parse_error_to_pr_error = |value_to_parse: (String, String)| {
         let i = value_to_parse.0;
         let option = value_to_parse.1;
@@ -523,51 +490,51 @@ fn parse_usize(matches: &Matches, opt: &str) -> Option<Result<usize, PrError>> {
         })
     };
     matches
-        .opt_str(opt)
-        .map(|i| (i, format!("-{}", opt)))
+        .value_of(opt)
+        .map(|i| (i.to_string(), format!("-{}", opt)))
         .map(from_parse_error_to_pr_error)
 }
 
 fn build_options(
-    matches: &Matches,
-    paths: &[String],
-    free_args: String,
+    matches: &ArgMatches,
+    paths: &[&str],
+    free_args: &str,
 ) -> Result<OutputOptions, PrError> {
-    let form_feed_used = matches.opt_present(options::FORM_FEED_OPTION)
-        || matches.opt_present(options::FORM_FEED_OPTION_SMALL);
+    let form_feed_used = matches.is_present(options::FORM_FEED);
 
-    let is_merge_mode = matches.opt_present(options::MERGE_FILES_PRINT);
+    let is_merge_mode = matches.is_present(options::MERGE);
 
-    if is_merge_mode && matches.opt_present(options::COLUMN_OPTION) {
+    if is_merge_mode && matches.is_present(options::COLUMN) {
         let err_msg = String::from("cannot specify number of columns when printing in parallel");
         return Err(PrError::EncounteredErrors(err_msg));
     }
 
-    if is_merge_mode && matches.opt_present(options::ACROSS_OPTION) {
+    if is_merge_mode && matches.is_present(options::ACROSS) {
         let err_msg = String::from("cannot specify both printing across and printing in parallel");
         return Err(PrError::EncounteredErrors(err_msg));
     }
 
-    let merge_files_print = if matches.opt_present(options::MERGE_FILES_PRINT) {
+    let merge_files_print = if matches.is_present(options::MERGE) {
         Some(paths.len())
     } else {
         None
     };
 
-    let header = matches.opt_str(options::STRING_HEADER_OPTION).unwrap_or(
-        if is_merge_mode || paths[0] == FILE_STDIN {
-            String::new()
+    let header = matches
+        .value_of(options::HEADER)
+        .unwrap_or(if is_merge_mode || paths[0] == FILE_STDIN {
+            ""
         } else {
-            paths[0].to_string()
-        },
-    );
+            paths[0]
+        })
+        .to_string();
 
     let default_first_number = NumberingMode::default().first_number;
-    let first_number = parse_usize(matches, options::FIRST_LINE_NUMBER_OPTION)
-        .unwrap_or(Ok(default_first_number))?;
+    let first_number =
+        parse_usize(matches, options::FIRST_LINE_NUMBER).unwrap_or(Ok(default_first_number))?;
 
     let number = matches
-        .opt_str(options::NUMBERING_MODE_OPTION)
+        .value_of(options::NUMBER_LINES)
         .map(|i| {
             let parse_result = i.parse::<usize>();
 
@@ -591,14 +558,14 @@ fn build_options(
             }
         })
         .or_else(|| {
-            if matches.opt_present(options::NUMBERING_MODE_OPTION) {
+            if matches.is_present(options::NUMBER_LINES) {
                 Some(NumberingMode::default())
             } else {
                 None
             }
         });
 
-    let double_space = matches.opt_present(options::DOUBLE_SPACE_OPTION);
+    let double_space = matches.is_present(options::DOUBLE_SPACE);
 
     let content_line_separator = if double_space {
         "\n".repeat(2)
@@ -617,7 +584,7 @@ fn build_options(
 
     // +page option is less priority than --pages
     let page_plus_re = Regex::new(r"\s*\+(\d+:*\d*)\s*").unwrap();
-    let start_page_in_plus_option = match page_plus_re.captures(&free_args).map(|i| {
+    let start_page_in_plus_option = match page_plus_re.captures(free_args).map(|i| {
         let unparsed_num = i.get(1).unwrap().as_str().trim();
         let x: Vec<_> = unparsed_num.split(':').collect();
         x[0].to_string().parse::<usize>().map_err(|_e| {
@@ -629,7 +596,7 @@ fn build_options(
     };
 
     let end_page_in_plus_option = match page_plus_re
-        .captures(&free_args)
+        .captures(free_args)
         .map(|i| i.get(1).unwrap().as_str().trim())
         .filter(|i| i.contains(':'))
         .map(|unparsed_num| {
@@ -647,7 +614,7 @@ fn build_options(
     };
 
     let invalid_pages_map = |i: String| {
-        let unparsed_value = matches.opt_str(options::PAGE_RANGE_OPTION).unwrap();
+        let unparsed_value = matches.value_of(options::PAGES).unwrap();
         i.parse::<usize>().map_err(|_e| {
             PrError::EncounteredErrors(format!(
                 "invalid --pages argument {}",
@@ -657,7 +624,7 @@ fn build_options(
     };
 
     let start_page = match matches
-        .opt_str(options::PAGE_RANGE_OPTION)
+        .value_of(options::PAGES)
         .map(|i| {
             let x: Vec<_> = i.split(':').collect();
             x[0].to_string()
@@ -669,7 +636,7 @@ fn build_options(
     };
 
     let end_page = match matches
-        .opt_str(options::PAGE_RANGE_OPTION)
+        .value_of(options::PAGES)
         .filter(|i| i.contains(':'))
         .map(|i| {
             let x: Vec<_> = i.split(':').collect();
@@ -697,12 +664,12 @@ fn build_options(
     };
 
     let page_length =
-        parse_usize(matches, options::PAGE_LENGTH_OPTION).unwrap_or(Ok(default_lines_per_page))?;
+        parse_usize(matches, options::PAGE_LENGTH).unwrap_or(Ok(default_lines_per_page))?;
 
     let page_length_le_ht = page_length < (HEADER_LINES_PER_PAGE + TRAILER_LINES_PER_PAGE);
 
     let display_header_and_trailer =
-        !(page_length_le_ht) && !matches.opt_present(options::NO_HEADER_TRAILER_OPTION);
+        !(page_length_le_ht) && !matches.is_present(options::OMIT_HEADER);
 
     let content_lines_per_page = if page_length_le_ht {
         page_length
@@ -710,23 +677,24 @@ fn build_options(
         page_length - (HEADER_LINES_PER_PAGE + TRAILER_LINES_PER_PAGE)
     };
 
-    let page_separator_char = if matches.opt_present(options::FORM_FEED_OPTION) {
+    let page_separator_char = if matches.is_present(options::FORM_FEED) {
         let bytes = vec![FF];
         String::from_utf8(bytes).unwrap()
     } else {
         "\n".to_string()
     };
 
-    let across_mode = matches.opt_present(options::ACROSS_OPTION);
+    let across_mode = matches.is_present(options::ACROSS);
 
-    let column_separator = match matches.opt_str(options::COLUMN_STRING_SEPARATOR_OPTION) {
+    let column_separator = match matches.value_of(options::COLUMN_STRING_SEPARATOR) {
         Some(x) => Some(x),
-        None => matches.opt_str(options::COLUMN_CHAR_SEPARATOR_OPTION),
+        None => matches.value_of(options::COLUMN_CHAR_SEPARATOR),
     }
+    .map(ToString::to_string)
     .unwrap_or_else(|| DEFAULT_COLUMN_SEPARATOR.to_string());
 
-    let default_column_width = if matches.opt_present(options::COLUMN_WIDTH_OPTION)
-        && matches.opt_present(options::COLUMN_CHAR_SEPARATOR_OPTION)
+    let default_column_width = if matches.is_present(options::COLUMN_WIDTH)
+        && matches.is_present(options::COLUMN_CHAR_SEPARATOR)
     {
         DEFAULT_COLUMN_WIDTH_WITH_S_OPTION
     } else {
@@ -734,12 +702,12 @@ fn build_options(
     };
 
     let column_width =
-        parse_usize(matches, options::COLUMN_WIDTH_OPTION).unwrap_or(Ok(default_column_width))?;
+        parse_usize(matches, options::COLUMN_WIDTH).unwrap_or(Ok(default_column_width))?;
 
-    let page_width = if matches.opt_present(options::JOIN_LINES_OPTION) {
+    let page_width = if matches.is_present(options::JOIN_LINES) {
         None
     } else {
-        match parse_usize(matches, options::PAGE_WIDTH_OPTION) {
+        match parse_usize(matches, options::PAGE_WIDTH) {
             Some(res) => Some(res?),
             None => None,
         }
@@ -747,7 +715,7 @@ fn build_options(
 
     let re_col = Regex::new(r"\s*-(\d+)\s*").unwrap();
 
-    let start_column_option = match re_col.captures(&free_args).map(|i| {
+    let start_column_option = match re_col.captures(free_args).map(|i| {
         let unparsed_num = i.get(1).unwrap().as_str().trim();
         unparsed_num.parse::<usize>().map_err(|_e| {
             PrError::EncounteredErrors(format!("invalid {} argument {}", "-", unparsed_num.quote()))
@@ -759,7 +727,7 @@ fn build_options(
 
     // --column has more priority than -column
 
-    let column_option_value = match parse_usize(matches, options::COLUMN_OPTION) {
+    let column_option_value = match parse_usize(matches, options::COLUMN) {
         Some(res) => Some(res?),
         None => start_column_option,
     };
@@ -771,9 +739,8 @@ fn build_options(
         across_mode,
     });
 
-    let offset_spaces =
-        " ".repeat(parse_usize(matches, options::OFFSET_SPACES_OPTION).unwrap_or(Ok(0))?);
-    let join_lines = matches.opt_present(options::JOIN_LINES_OPTION);
+    let offset_spaces = " ".repeat(parse_usize(matches, options::INDENT).unwrap_or(Ok(0))?);
+    let join_lines = matches.is_present(options::JOIN_LINES);
 
     let col_sep_for_printing = column_mode_options
         .as_ref()
@@ -850,7 +817,7 @@ fn open(path: &str) -> Result<Box<dyn Read>, PrError> {
         .unwrap_or_else(|_| Err(PrError::NotExists(path.to_string())))
 }
 
-fn split_lines_if_form_feed(file_content: Result<String, IOError>) -> Vec<FileLine> {
+fn split_lines_if_form_feed(file_content: Result<String, std::io::Error>) -> Vec<FileLine> {
     file_content
         .map(|content| {
             let mut lines = Vec::new();
@@ -916,8 +883,7 @@ fn read_stream_and_create_pages(
 
     Box::new(
         lines
-            .map(split_lines_if_form_feed)
-            .flatten()
+            .flat_map(split_lines_if_form_feed)
             .enumerate()
             .map(move |(i, line)| FileLine {
                 line_number: i + start_line_number,
@@ -968,7 +934,7 @@ fn read_stream_and_create_pages(
     )
 }
 
-fn mpr(paths: &[String], options: &OutputOptions) -> Result<i32, PrError> {
+fn mpr(paths: &[&str], options: &OutputOptions) -> Result<i32, PrError> {
     let n_files = paths.len();
 
     // Check if files exists
@@ -982,20 +948,18 @@ fn mpr(paths: &[String], options: &OutputOptions) -> Result<i32, PrError> {
         .map(|(i, path)| {
             let lines = BufReader::with_capacity(READ_BUFFER_SIZE, open(path).unwrap()).lines();
 
-            read_stream_and_create_pages(options, lines, i)
-                .map(move |(x, line)| {
-                    let file_line = line;
-                    let page_number = x + 1;
-                    file_line
-                        .into_iter()
-                        .map(|fl| FileLine {
-                            page_number,
-                            group_key: page_number * n_files + fl.file_id,
-                            ..fl
-                        })
-                        .collect::<Vec<_>>()
-                })
-                .flatten()
+            read_stream_and_create_pages(options, lines, i).flat_map(move |(x, line)| {
+                let file_line = line;
+                let page_number = x + 1;
+                file_line
+                    .into_iter()
+                    .map(|fl| FileLine {
+                        page_number,
+                        group_key: page_number * n_files + fl.file_id,
+                        ..fl
+                    })
+                    .collect::<Vec<_>>()
+            })
         })
         .kmerge_by(|a, b| {
             if a.group_key == b.group_key {
@@ -1010,7 +974,7 @@ fn mpr(paths: &[String], options: &OutputOptions) -> Result<i32, PrError> {
     let mut lines = Vec::new();
     let mut page_counter = start_page;
 
-    for (_key, file_line_group) in file_line_groups.into_iter() {
+    for (_key, file_line_group) in &file_line_groups {
         for file_line in file_line_group {
             if let Err(e) = file_line.line_content {
                 return Err(e.into());
@@ -1030,7 +994,11 @@ fn mpr(paths: &[String], options: &OutputOptions) -> Result<i32, PrError> {
     Ok(0)
 }
 
-fn print_page(lines: &[FileLine], options: &OutputOptions, page: usize) -> Result<usize, IOError> {
+fn print_page(
+    lines: &[FileLine],
+    options: &OutputOptions,
+    page: usize,
+) -> Result<usize, std::io::Error> {
     let line_separator = options.line_separator.as_bytes();
     let page_separator = options.page_separator_char.as_bytes();
 
@@ -1062,7 +1030,7 @@ fn write_columns(
     lines: &[FileLine],
     options: &OutputOptions,
     out: &mut impl Write,
-) -> Result<usize, IOError> {
+) -> Result<usize, std::io::Error> {
     let line_separator = options.content_line_separator.as_bytes();
 
     let content_lines_per_page = if options.double_space {
diff --git a/src/uu/printenv/Cargo.toml b/src/uu/printenv/Cargo.toml
index eaf482b21..7c708602d 100644
--- a/src/uu/printenv/Cargo.toml
+++ b/src/uu/printenv/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_printenv"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "printenv ~ (uutils) display value of environment VAR"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/printenv"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/printenv"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/printenv.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "printenv"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/printenv/LICENSE b/src/uu/printenv/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/printenv/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/printenv/src/main.rs b/src/uu/printenv/src/main.rs
index b61cbe90a..fcf429776 100644
--- a/src/uu/printenv/src/main.rs
+++ b/src/uu/printenv/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_printenv);
+uucore::bin!(uu_printenv);
diff --git a/src/uu/printenv/src/printenv.rs b/src/uu/printenv/src/printenv.rs
index 5d32cfbcc..c5832c4df 100644
--- a/src/uu/printenv/src/printenv.rs
+++ b/src/uu/printenv/src/printenv.rs
@@ -7,23 +7,20 @@
 
 /* last synced with: printenv (GNU coreutils) 8.13 */
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::env;
+use uucore::{error::UResult, format_usage};
 
 static ABOUT: &str = "Display the values of the specified environment VARIABLE(s), or (with no VARIABLE) display name and value pairs for them all.";
+const USAGE: &str = "{} [VARIABLE]... [OPTION]...";
 
 static OPT_NULL: &str = "null";
 
 static ARG_VARIABLES: &str = "variables";
 
-fn usage() -> String {
-    format!("{0} [VARIABLE]... [OPTION]...", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let variables: Vec<String> = matches
         .values_of(ARG_VARIABLES)
@@ -40,30 +37,40 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         for (env_var, value) in env::vars() {
             print!("{}={}{}", env_var, value, separator);
         }
-        return 0;
+        return Ok(());
     }
 
+    let mut not_found = false;
     for env_var in variables {
         if let Ok(var) = env::var(env_var) {
             print!("{}{}", var, separator);
+        } else {
+            not_found = true;
         }
     }
-    0
+
+    if not_found {
+        Err(1.into())
+    } else {
+        Ok(())
+    }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_NULL)
-                .short("0")
+            Arg::new(OPT_NULL)
+                .short('0')
                 .long(OPT_NULL)
                 .help("end each output line with 0 byte rather than newline"),
         )
         .arg(
-            Arg::with_name(ARG_VARIABLES)
-                .multiple(true)
+            Arg::new(ARG_VARIABLES)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .min_values(1),
         )
diff --git a/src/uu/printf/Cargo.toml b/src/uu/printf/Cargo.toml
index 50c454db5..02167bcbb 100644
--- a/src/uu/printf/Cargo.toml
+++ b/src/uu/printf/Cargo.toml
@@ -1,15 +1,15 @@
 [package]
 name = "uu_printf"
-version = "0.0.8"
+version = "0.0.13"
 authors = [
-    "Nathan Ross",
-    "uutils developers",
+  "Nathan Ross",
+  "uutils developers",
 ]
 license = "MIT"
 description = "printf ~ (uutils) FORMAT and display ARGUMENTS"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/printf"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/printf"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -18,15 +18,9 @@ edition = "2018"
 path = "src/printf.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-itertools = "0.8.0"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version = ">=0.0.11", package = "uucore", path = "../../uucore", features = ["memo"] }
 
 [[bin]]
 name = "printf"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/printf/LICENSE b/src/uu/printf/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/printf/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/printf/src/cli.rs b/src/uu/printf/src/cli.rs
deleted file mode 100644
index fa2fda1d2..000000000
--- a/src/uu/printf/src/cli.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//! stdio convenience fns
-
-// spell-checker:ignore (ToDO) bslice
-
-use std::io::{stdout, Write};
-
-pub const EXIT_OK: i32 = 0;
-pub const EXIT_ERR: i32 = 1;
-
-// by default stdout only flushes
-// to console when a newline is passed.
-pub fn flush_char(c: char) {
-    print!("{}", c);
-    let _ = stdout().flush();
-}
-pub fn flush_str(s: &str) {
-    print!("{}", s);
-    let _ = stdout().flush();
-}
-pub fn flush_bytes(bslice: &[u8]) {
-    let _ = stdout().write(bslice);
-    let _ = stdout().flush();
-}
diff --git a/src/uu/printf/src/main.rs b/src/uu/printf/src/main.rs
index 9def7dafe..7bb4ae74d 100644
--- a/src/uu/printf/src/main.rs
+++ b/src/uu/printf/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_printf);
+uucore::bin!(uu_printf);
diff --git a/src/uu/printf/src/mod.rs b/src/uu/printf/src/mod.rs
index 5ed2ecea8..26710c101 100644
--- a/src/uu/printf/src/mod.rs
+++ b/src/uu/printf/src/mod.rs
@@ -1,3 +1 @@
 mod cli;
-mod memo;
-mod tokenize;
diff --git a/src/uu/printf/src/printf.rs b/src/uu/printf/src/printf.rs
index d3c8dca90..662db1ed5 100644
--- a/src/uu/printf/src/printf.rs
+++ b/src/uu/printf/src/printf.rs
@@ -2,264 +2,255 @@
 // spell-checker:ignore (change!) each's
 // spell-checker:ignore (ToDO) LONGHELP FORMATSTRING templating parameterizing formatstr
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
+use uucore::error::{UResult, UUsageError};
 use uucore::InvalidEncodingHandling;
-
-mod cli;
-mod memo;
-mod tokenize;
+use uucore::{format_usage, memo};
 
 const VERSION: &str = "version";
 const HELP: &str = "help";
-static LONGHELP_LEAD: &str = "printf
+const USAGE: &str = "{} FORMATSTRING [ARGUMENT]...";
+const ABOUT: &str = "Print output based off of the format string and proceeding arguments.";
+const AFTER_HELP: &str = "
+basic anonymous string templating:
 
- USAGE: printf FORMATSTRING [ARGUMENT]...
+prints format string at least once, repeating as long as there are remaining arguments
+output prints escaped literals in the format string as character literals
+output replaces anonymous fields with the next unused argument, formatted according to the field.
 
- basic anonymous string templating:
+Prints the , replacing escaped character sequences with character literals
+  and substitution field sequences with passed arguments
 
- prints format string at least once, repeating as long as there are remaining arguments
- output prints escaped literals in the format string as character literals
- output replaces anonymous fields with the next unused argument, formatted according to the field.
+literally, with the exception of the below
+  escaped character sequences, and the substitution sequences described further down.
 
-Options:
-    --help              display this help and exit
-    --version           output version information and exit
+ESCAPE SEQUENCES
 
-";
-static LONGHELP_BODY: &str = "
-  Prints the , replacing escaped character sequences with character literals
-    and substitution field sequences with passed arguments
+The following escape sequences, organized here in alphabetical order,
+will print the corresponding character literal:
 
- literally, with the exception of the below
-    escaped character sequences, and the substitution sequences described further down.
+\"   double quote
 
-  ESCAPE SEQUENCES
+\\\\    backslash
 
-  The following escape sequences, organized here in alphabetical order,
-  will print the corresponding character literal:
+\\a  alert (BEL)
 
-  \"   double quote
+\\b  backspace
 
-  \\\\    backslash
+\\c  End-of-Input
 
-  \\a  alert (BEL)
+\\e  escape
 
-  \\b  backspace
+\\f  form feed
 
-  \\c  End-of-Input
+\\n  new line
 
-  \\e  escape
+\\r  carriage return
 
-  \\f  form feed
+\\t  horizontal tab
 
-  \\n  new line
+\\v  vertical tab
 
-  \\r  carriage return
+\\NNN byte with value expressed in octal value NNN (1 to 3 digits)
+      values greater than 256 will be treated
 
-  \\t  horizontal tab
+\\xHH byte with value expressed in hexadecimal value NN (1 to 2 digits)
 
-  \\v  vertical tab
+\\uHHHH Unicode (IEC 10646) character with value expressed in hexadecimal value HHHH (4 digits)
 
-  \\NNN byte with value expressed in octal value NNN (1 to 3 digits)
-        values greater than 256 will be treated
+\\uHHHH Unicode character with value expressed in hexadecimal value HHHH (8 digits)
 
-  \\xHH byte with value expressed in hexadecimal value NN (1 to 2 digits)
+%% a single %
 
-  \\uHHHH Unicode (IEC 10646) character with value expressed in hexadecimal value HHHH (4 digits)
+SUBSTITUTIONS
 
-  \\uHHHH Unicode character with value expressed in hexadecimal value HHHH (8 digits)
+SUBSTITUTION QUICK REFERENCE
 
-  %% a single %
+Fields
 
-  SUBSTITUTIONS
+%s - string
+%b - string parsed for literals
+  second parameter is max length
 
-  SUBSTITUTION QUICK REFERENCE
+%c - char
+  no second parameter
 
-  Fields
+%i or %d - 64-bit integer
+%u - 64 bit unsigned integer
+%x or %X - 64-bit unsigned integer as hex
+%o - 64-bit unsigned integer as octal
+  second parameter is min-width, integer
+   output below that width is padded with leading zeroes
 
-  %s - string
-  %b - string parsed for literals
-    second parameter is max length
+%f or %F - decimal floating point value
+%e or %E - scientific notation floating point value
+%g or %G - shorter of specially interpreted decimal or SciNote floating point value.
+  second parameter is
+    -max places after decimal point for floating point output
+    -max number of significant digits for scientific notation output
 
-  %c - char
-    no second parameter
+parameterizing fields
 
-  %i or %d - 64-bit integer
-  %u - 64 bit unsigned integer
-  %x or %X - 64-bit unsigned integer as hex
-  %o - 64-bit unsigned integer as octal
-    second parameter is min-width, integer
-     output below that width is padded with leading zeroes
+examples:
 
-  %f or %F - decimal floating point value
-  %e or %E - scientific notation floating point value
-  %g or %G - shorter of specially interpreted decimal or SciNote floating point value.
-    second parameter is
-      -max places after decimal point for floating point output
-      -max number of significant digits for scientific notation output
+printf '%4.3i' 7
+has a first parameter of 4
+   and a second parameter of 3
+will result in ' 007'
 
-  parameterizing fields
+printf '%.1s' abcde
+has no first parameter
+   and a second parameter of 1
+will result in 'a'
 
-  examples:
+printf '%4c' q
+has a first parameter of 4
+   and no second parameter
+will result in  '   q'
 
-  printf '%4.3i' 7
-  has a first parameter of 4
-     and a second parameter of 3
-  will result in ' 007'
+The first parameter of a field is the minimum width to pad the output to
+ if the output is less than this absolute value of this width,
+ it will be padded with leading spaces, or, if the argument is negative,
+ with trailing spaces. the default is zero.
 
-  printf '%.1s' abcde
-  has no first parameter
-     and a second parameter of 1
-  will result in 'a'
+The second parameter of a field is particular to the output field type.
+ defaults can be found in the full substitution help below
 
-  printf '%4c' q
-  has a first parameter of 4
-     and no second parameter
-  will result in  '   q'
+special prefixes to numeric arguments
+  0 (e.g. 010) - interpret argument as octal (integer output fields only)
+  0x (e.g. 0xABC) - interpret argument as hex (numeric output fields only)
+  \' (e.g. \'a) - interpret argument as a character constant
 
-  The first parameter of a field is the minimum width to pad the output to
-   if the output is less than this absolute value of this width,
-   it will be padded with leading spaces, or, if the argument is negative,
-   with trailing spaces. the default is zero.
+HOW TO USE SUBSTITUTIONS
 
-  The second parameter of a field is particular to the output field type.
-   defaults can be found in the full substitution help below
+Substitutions are used to pass additional argument(s) into the FORMAT string, to be formatted a
+particular way. E.g.
 
-  special prefixes to numeric arguments
-    0 (e.g. 010) - interpret argument as octal (integer output fields only)
-    0x (e.g. 0xABC) - interpret argument as hex (numeric output fields only)
-    \' (e.g. \'a) - interpret argument as a character constant
+    printf 'the letter %X comes before the letter %X' 10 11
 
-  HOW TO USE SUBSTITUTIONS
+will print
 
-  Substitutions are used to pass additional argument(s) into the FORMAT string, to be formatted a
-  particular way. E.g.
+   'the letter A comes before the letter B'
 
-      printf 'the letter %X comes before the letter %X' 10 11
+because the substitution field %X means
+'take an integer argument and write it as a hexadecimal number'
 
-  will print
+Passing more arguments than are in the format string will cause the format string to be
+ repeated for the remaining substitutions
 
-     'the letter A comes before the letter B'
+   printf 'it is %i F in %s \n' 22 Portland 25 Boston 27 New York
 
-  because the substitution field %X means
-  'take an integer argument and write it as a hexadecimal number'
+will print
 
-  Passing more arguments than are in the format string will cause the format string to be
-   repeated for the remaining substitutions
+   'it is 22 F in Portland
+    it is 25 F in Boston
+    it is 27 F in Boston
+   '
+If a format string is printed but there are less arguments remaining
+ than there are substitution fields, substitution fields without
+ an argument will default to empty strings, or for numeric fields
+ the value 0
 
-     printf 'it is %i F in %s \n' 22 Portland 25 Boston 27 New York
+AVAILABLE SUBSTITUTIONS
 
-  will print
+This program, like GNU coreutils printf,
+interprets a modified subset of the POSIX C printf spec,
+a quick reference to substitutions is below.
 
-     'it is 22 F in Portland
-      it is 25 F in Boston
-      it is 27 F in Boston
-     '
-  If a format string is printed but there are less arguments remaining
-   than there are substitution fields, substitution fields without
-   an argument will default to empty strings, or for numeric fields
-   the value 0
+ STRING SUBSTITUTIONS
+  All string fields have a 'max width' parameter
+  %.3s means 'print no more than three characters of the original input'
 
-  AVAILABLE SUBSTITUTIONS
+ %s - string
 
-  This program, like GNU coreutils printf,
-  interprets a modified subset of the POSIX C printf spec,
-  a quick reference to substitutions is below.
+ %b - escaped string - the string will be checked for any escaped literals from
+       the escaped literal list above, and translate them to literal characters.
+       e.g. \\n will be transformed into a newline character.
 
-   STRING SUBSTITUTIONS
-    All string fields have a 'max width' parameter
-    %.3s means 'print no more than three characters of the original input'
+      One special rule about %b mode is that octal literals are interpreted differently
+      In arguments passed by %b, pass octal-interpreted literals must be in the form of \\0NNN
+      instead of \\NNN. (Although, for legacy reasons, octal literals in the form of \\NNN will
+      still be interpreted and not throw a warning, you will have problems if you use this for a
+      literal whose code begins with zero, as it will be viewed as in \\0NNN form.)
 
-   %s - string
+ CHAR SUBSTITUTIONS
+  The character field does not have a secondary parameter.
 
-   %b - escaped string - the string will be checked for any escaped literals from
-         the escaped literal list above, and translate them to literal characters.
-         e.g. \\n will be transformed into a newline character.
+ %c - a single character
 
-        One special rule about %b mode is that octal literals are interpreted differently
-        In arguments passed by %b, pass octal-interpreted literals must be in the form of \\0NNN
-        instead of \\NNN. (Although, for legacy reasons, octal literals in the form of \\NNN will
-        still be interpreted and not throw a warning, you will have problems if you use this for a
-        literal whose code begins with zero, as it will be viewed as in \\0NNN form.)
+ INTEGER SUBSTITUTIONS
+  All integer fields have a 'pad with zero' parameter
+  %.4i means an integer which if it is less than 4 digits in length,
+  is padded with leading zeros until it is 4 digits in length.
 
-   CHAR SUBSTITUTIONS
-    The character field does not have a secondary parameter.
+ %d or %i - 64-bit integer
 
-   %c - a single character
+ %u - 64 bit unsigned integer
 
-   INTEGER SUBSTITUTIONS
-    All integer fields have a 'pad with zero' parameter
-    %.4i means an integer which if it is less than 4 digits in length,
-    is padded with leading zeros until it is 4 digits in length.
+ %x or %X - 64 bit unsigned integer printed in Hexadecimal (base 16)
+          %X instead of %x means to use uppercase letters for 'a' through 'f'
 
-   %d or %i - 64-bit integer
+ %o - 64 bit unsigned integer printed in octal (base 8)
 
-   %u - 64 bit unsigned integer
+ FLOATING POINT SUBSTITUTIONS
 
-   %x or %X - 64 bit unsigned integer printed in Hexadecimal (base 16)
-            %X instead of %x means to use uppercase letters for 'a' through 'f'
+  All floating point fields have a 'max decimal places / max significant digits' parameter
+  %.10f means a decimal floating point with 7 decimal places past 0
+  %.10e means a scientific notation number with 10 significant digits
+  %.10g means the same behavior for decimal and Sci. Note, respectively, and provides the shorter
+        of each's output.
 
-   %o - 64 bit unsigned integer printed in octal (base 8)
+  Like with GNU coreutils, the value after the decimal point is these outputs is parsed as a
+  double first before being rendered to text. For both implementations do not expect meaningful
+  precision past the 18th decimal place. When using a number of decimal places that is 18 or
+  higher, you can expect variation in output between GNU coreutils printf and this printf at the
+  18th decimal place of +/- 1
 
-   FLOATING POINT SUBSTITUTIONS
+ %f - floating point value presented in decimal, truncated and displayed to 6 decimal places by
+      default. There is not past-double behavior parity with Coreutils printf, values are not
+      estimated or adjusted beyond input values.
 
-    All floating point fields have a 'max decimal places / max significant digits' parameter
-    %.10f means a decimal floating point with 7 decimal places past 0
-    %.10e means a scientific notation number with 10 significant digits
-    %.10g means the same behavior for decimal and Sci. Note, respectively, and provides the shorter
-          of each's output.
+ %e or %E - floating point value presented in scientific notation
+          7 significant digits by default
+          %E means use to use uppercase E for the mantissa.
 
-    Like with GNU coreutils, the value after the decimal point is these outputs is parsed as a
-    double first before being rendered to text. For both implementations do not expect meaningful
-    precision past the 18th decimal place. When using a number of decimal places that is 18 or
-    higher, you can expect variation in output between GNU coreutils printf and this printf at the
-    18th decimal place of +/- 1
+ %g or %G - floating point value presented in the shorter of decimal and scientific notation
+          behaves differently from %f and %E, please see posix printf spec for full details,
+          some examples of different behavior:
 
-   %f - floating point value presented in decimal, truncated and displayed to 6 decimal places by
-        default. There is not past-double behavior parity with Coreutils printf, values are not
-        estimated or adjusted beyond input values.
+          Sci Note has 6 significant digits by default
+          Trailing zeroes are removed
+          Instead of being truncated, digit after last is rounded
 
-   %e or %E - floating point value presented in scientific notation
-            7 significant digits by default
-            %E means use to use uppercase E for the mantissa.
+ Like other behavior in this utility, the design choices of floating point
+  behavior in this utility is selected to reproduce in exact
+  the behavior of GNU coreutils' printf from an inputs and outputs standpoint.
 
-   %g or %G - floating point value presented in the shorter of decimal and scientific notation
-            behaves differently from %f and %E, please see posix printf spec for full details,
-            some examples of different behavior:
+USING PARAMETERS
+ Most substitution fields can be parameterized using up to 2 numbers that can
+ be passed to the field, between the % sign and the field letter.
 
-            Sci Note has 6 significant digits by default
-            Trailing zeroes are removed
-            Instead of being truncated, digit after last is rounded
+ The 1st parameter always indicates the minimum width of output, it is useful for creating
+   columnar output. Any output that would be less than this minimum width is padded with
+   leading spaces
+ The 2nd parameter is proceeded by a dot.
+ You do not have to use parameters
 
-   Like other behavior in this utility, the design choices of floating point
-    behavior in this utility is selected to reproduce in exact
-    the behavior of GNU coreutils' printf from an inputs and outputs standpoint.
+SPECIAL FORMS OF INPUT
+ For numeric input, the following additional forms of input are accepted besides decimal:
 
-  USING PARAMETERS
-   Most substitution fields can be parameterized using up to 2 numbers that can
-   be passed to the field, between the % sign and the field letter.
+  Octal (only with integer): if the argument begins with a 0 the proceeding characters
+    will be interpreted as octal (base 8) for integer fields
 
-   The 1st parameter always indicates the minimum width of output, it is useful for creating
-     columnar output. Any output that would be less than this minimum width is padded with
-     leading spaces
-   The 2nd parameter is proceeded by a dot.
-   You do not have to use parameters
+  Hexadecimal: if the argument begins with 0x the proceeding characters will be interpreted
+    will be interpreted as hex (base 16) for any numeric fields
+    for float fields, hexadecimal input results in a precision
+    limit (in converting input past the decimal point) of 10^-15
 
-  SPECIAL FORMS OF INPUT
-   For numeric input, the following additional forms of input are accepted besides decimal:
-
-    Octal (only with integer): if the argument begins with a 0 the proceeding characters
-      will be interpreted as octal (base 8) for integer fields
-
-    Hexadecimal: if the argument begins with 0x the proceeding characters will be interpreted
-      will be interpreted as hex (base 16) for any numeric fields
-      for float fields, hexadecimal input results in a precision
-      limit (in converting input past the decimal point) of 10^-15
-
-    Character Constant: if the argument begins with a single quote character, the first byte
-      of the next character will be interpreted as an 8-bit unsigned integer. If there are
-      additional bytes, they will throw an error (unless the environment variable POSIXLY_CORRECT
-      is set)
+  Character Constant: if the argument begins with a single quote character, the first byte
+    of the next character will be interpreted as an 8-bit unsigned integer. If there are
+    additional bytes, they will throw an error (unless the environment variable POSIXLY_CORRECT
+    is set)
 
 WRITTEN BY :
   Nathan E. Ross, et al. for the uutils project
@@ -273,34 +264,43 @@ COPYRIGHT :
 
 ";
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+mod options {
+    pub const FORMATSTRING: &str = "FORMATSTRING";
+    pub const ARGUMENT: &str = "ARGUMENT";
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
+    let matches = uu_app().get_matches_from(args);
 
-    if args.len() <= 1 {
-        println!(
-            "{0}: missing operand\nTry '{1} --help' for more information.",
-            uucore::util_name(),
-            uucore::execution_phrase()
-        );
-        return 1;
-    }
-    let formatstr = &args[1];
+    let format_string = matches
+        .value_of(options::FORMATSTRING)
+        .ok_or_else(|| UUsageError::new(1, "missing operand"))?;
+    let values: Vec<String> = match matches.values_of(options::ARGUMENT) {
+        Some(s) => s.map(|s| s.to_string()).collect(),
+        None => vec![],
+    };
 
-    if formatstr == "--help" {
-        print!("{} {}", LONGHELP_LEAD, LONGHELP_BODY);
-    } else if formatstr == "--version" {
-        println!("{} {}", uucore::util_name(), crate_version!());
-    } else {
-        let printf_args = &args[2..];
-        memo::Memo::run_all(formatstr, printf_args);
-    }
-    0
+    memo::Memo::run_all(format_string, &values[..])?;
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
-        .arg(Arg::with_name(VERSION).long(VERSION))
-        .arg(Arg::with_name(HELP).long(HELP))
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .allow_hyphen_values(true)
+        .version(crate_version!())
+        .about(ABOUT)
+        .after_help(AFTER_HELP)
+        .override_usage(format_usage(USAGE))
+        .arg(Arg::new(HELP).long(HELP).help("Print help information"))
+        .arg(
+            Arg::new(VERSION)
+                .long(VERSION)
+                .help("Print version information"),
+        )
+        .arg(Arg::new(options::FORMATSTRING))
+        .arg(Arg::new(options::ARGUMENT).multiple_occurrences(true))
 }
diff --git a/src/uu/printf/src/tokenize/num_format/formatters/decf.rs b/src/uu/printf/src/tokenize/num_format/formatters/decf.rs
deleted file mode 100644
index 3376345e0..000000000
--- a/src/uu/printf/src/tokenize/num_format/formatters/decf.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-// 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};
-
-fn get_len_fmt_primitive(fmt: &FormatPrimitive) -> usize {
-    let mut len = 0;
-    if let Some(ref s) = fmt.prefix {
-        len += s.len();
-    }
-    if let Some(ref s) = fmt.pre_decimal {
-        len += s.len();
-    }
-    if let Some(ref s) = fmt.post_decimal {
-        len += s.len();
-    }
-    if let Some(ref s) = fmt.suffix {
-        len += s.len();
-    }
-    len
-}
-
-pub struct Decf;
-
-impl Decf {
-    pub fn new() -> Decf {
-        Decf
-    }
-}
-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_sci = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            Some(*field.field_char == 'G'),
-        );
-        // strip trailing zeroes
-        if let Some(ref post_dec) = f_sci.post_decimal {
-            let trimmed = post_dec.trim_end_matches('0');
-            if trimmed.len() != post_dec.len() {
-                f_sci.post_decimal = Some(trimmed.to_owned());
-            }
-        }
-        let f_fl = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            None,
-        );
-        Some(
-            if get_len_fmt_primitive(&f_fl) >= get_len_fmt_primitive(&f_sci) {
-                f_sci
-            } else {
-                f_fl
-            },
-        )
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
diff --git a/src/uu/ptx/Cargo.toml b/src/uu/ptx/Cargo.toml
index 06eb15ee8..73f4bad16 100644
--- a/src/uu/ptx/Cargo.toml
+++ b/src/uu/ptx/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_ptx"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "ptx ~ (uutils) display a permuted index of input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/ptx"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ptx"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,19 +15,10 @@ edition = "2018"
 path = "src/ptx.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-aho-corasick = "0.7.3"
-libc = "0.2.42"
-memchr = "2.2.0"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 regex = "1.0.1"
-regex-syntax = "0.6.7"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "ptx"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/ptx/LICENSE b/src/uu/ptx/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/ptx/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/ptx/src/main.rs b/src/uu/ptx/src/main.rs
index b627b801f..926e5f2dd 100644
--- a/src/uu/ptx/src/main.rs
+++ b/src/uu/ptx/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_ptx);
+uucore::bin!(uu_ptx);
diff --git a/src/uu/ptx/src/ptx.rs b/src/uu/ptx/src/ptx.rs
index 3619b8d4d..86a123530 100644
--- a/src/uu/ptx/src/ptx.rs
+++ b/src/uu/ptx/src/ptx.rs
@@ -7,26 +7,29 @@
 
 // spell-checker:ignore (ToDOs) corasick memchr Roff trunc oset iset
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use regex::Regex;
 use std::cmp;
 use std::collections::{BTreeSet, HashMap, HashSet};
 use std::default::Default;
+use std::error::Error;
+use std::fmt::{Display, Formatter};
 use std::fs::File;
 use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
+use std::num::ParseIntError;
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{FromIo, UError, UResult};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static NAME: &str = "ptx";
-static BRIEF: &str = "Usage: ptx [OPTION]... [INPUT]...   (without -G) or: \
-                 ptx -G [OPTION]... [INPUT [OUTPUT]] \n Output a permuted index, \
-                 including context, of the words in the input files. \n\n Mandatory \
-                 arguments to long options are mandatory for short options too.\n
-                 With no FILE, or when FILE is -, read standard input. \
-                Default is '-F /'.";
+const USAGE: &str = "\
+    {} [OPTION]... [INPUT]...
+    {} -G [OPTION]... [INPUT [OUTPUT]]";
+
+const ABOUT: &str = "\
+    Output a permuted index, including context, of the words in the input files. \n\n\
+    Mandatory arguments to long options are mandatory for short options too.\n\
+    With no FILE, or when FILE is -, read standard input. Default is '-F /'.";
 
 #[derive(Debug)]
 enum OutFormat {
@@ -51,8 +54,8 @@ struct Config {
 }
 
 impl Default for Config {
-    fn default() -> Config {
-        Config {
+    fn default() -> Self {
+        Self {
             format: OutFormat::Dumb,
             gnu_ext: true,
             auto_ref: false,
@@ -68,17 +71,21 @@ impl Default for Config {
     }
 }
 
-fn read_word_filter_file(matches: &clap::ArgMatches, option: &str) -> HashSet<String> {
+fn read_word_filter_file(
+    matches: &clap::ArgMatches,
+    option: &str,
+) -> std::io::Result<HashSet<String>> {
     let filename = matches
         .value_of(option)
         .expect("parsing options failed!")
         .to_string();
-    let reader = BufReader::new(crash_if_err!(1, File::open(filename)));
+    let file = File::open(filename)?;
+    let reader = BufReader::new(file);
     let mut words: HashSet<String> = HashSet::new();
     for word in reader.lines() {
-        words.insert(crash_if_err!(1, word));
+        words.insert(word?);
     }
-    words
+    Ok(words)
 }
 
 #[derive(Debug)]
@@ -91,19 +98,23 @@ struct WordFilter {
 }
 
 impl WordFilter {
-    fn new(matches: &clap::ArgMatches, config: &Config) -> WordFilter {
+    fn new(matches: &clap::ArgMatches, config: &Config) -> UResult<Self> {
         let (o, oset): (bool, HashSet<String>) = if matches.is_present(options::ONLY_FILE) {
-            (true, read_word_filter_file(matches, options::ONLY_FILE))
+            let words =
+                read_word_filter_file(matches, options::ONLY_FILE).map_err_context(String::new)?;
+            (true, words)
         } else {
             (false, HashSet::new())
         };
         let (i, iset): (bool, HashSet<String>) = if matches.is_present(options::IGNORE_FILE) {
-            (true, read_word_filter_file(matches, options::IGNORE_FILE))
+            let words = read_word_filter_file(matches, options::IGNORE_FILE)
+                .map_err_context(String::new)?;
+            (true, words)
         } else {
             (false, HashSet::new())
         };
         if matches.is_present(options::BREAK_FILE) {
-            crash!(1, "-b not implemented yet");
+            return Err(PtxError::NotImplemented("-b").into());
         }
         // Ignore empty string regex from cmd-line-args
         let arg_reg: Option<String> = if matches.is_present(options::WORD_REGEXP) {
@@ -130,13 +141,13 @@ impl WordFilter {
                 }
             }
         };
-        WordFilter {
+        Ok(Self {
             only_specified: o,
             ignore_specified: i,
             only_set: oset,
             ignore_set: iset,
             word_regex: reg,
-        }
+        })
     }
 }
 
@@ -150,7 +161,29 @@ struct WordRef {
     filename: String,
 }
 
-fn get_config(matches: &clap::ArgMatches) -> Config {
+#[derive(Debug)]
+enum PtxError {
+    DumbFormat,
+    NotImplemented(&'static str),
+    ParseError(ParseIntError),
+}
+
+impl Error for PtxError {}
+impl UError for PtxError {}
+
+impl Display for PtxError {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Self::DumbFormat => {
+                write!(f, "There is no dumb format with GNU extensions disabled")
+            }
+            Self::NotImplemented(s) => write!(f, "{} not implemented yet", s),
+            Self::ParseError(e) => e.fmt(f),
+        }
+    }
+}
+
+fn get_config(matches: &clap::ArgMatches) -> UResult<Config> {
     let mut config: Config = Default::default();
     let err_msg = "parsing options failed";
     if matches.is_present(options::TRADITIONAL) {
@@ -158,10 +191,10 @@ fn get_config(matches: &clap::ArgMatches) -> Config {
         config.format = OutFormat::Roff;
         config.context_regex = "[^ \t\n]+".to_owned();
     } else {
-        crash!(1, "GNU extensions not implemented yet");
+        return Err(PtxError::NotImplemented("GNU extensions").into());
     }
     if matches.is_present(options::SENTENCE_REGEXP) {
-        crash!(1, "-S not implemented yet");
+        return Err(PtxError::NotImplemented("-S").into());
     }
     config.auto_ref = matches.is_present(options::AUTO_REFERENCE);
     config.input_ref = matches.is_present(options::REFERENCES);
@@ -180,15 +213,18 @@ fn get_config(matches: &clap::ArgMatches) -> Config {
             .to_string();
     }
     if matches.is_present(options::WIDTH) {
-        let width_str = matches.value_of(options::WIDTH).expect(err_msg).to_string();
-        config.line_width = crash_if_err!(1, (&width_str).parse::<usize>());
+        config.line_width = matches
+            .value_of(options::WIDTH)
+            .expect(err_msg)
+            .parse()
+            .map_err(PtxError::ParseError)?;
     }
     if matches.is_present(options::GAP_SIZE) {
-        let gap_str = matches
+        config.gap_size = matches
             .value_of(options::GAP_SIZE)
             .expect(err_msg)
-            .to_string();
-        config.gap_size = crash_if_err!(1, (&gap_str).parse::<usize>());
+            .parse()
+            .map_err(PtxError::ParseError)?;
     }
     if matches.is_present(options::FORMAT_ROFF) {
         config.format = OutFormat::Roff;
@@ -196,7 +232,7 @@ fn get_config(matches: &clap::ArgMatches) -> Config {
     if matches.is_present(options::FORMAT_TEX) {
         config.format = OutFormat::Tex;
     }
-    config
+    Ok(config)
 }
 
 struct FileContent {
@@ -207,7 +243,7 @@ struct FileContent {
 
 type FileMap = HashMap<String, FileContent>;
 
-fn read_input(input_files: &[String], config: &Config) -> FileMap {
+fn read_input(input_files: &[String], config: &Config) -> std::io::Result<FileMap> {
     let mut file_map: FileMap = HashMap::new();
     let mut files = Vec::new();
     if input_files.is_empty() {
@@ -224,10 +260,10 @@ fn read_input(input_files: &[String], config: &Config) -> FileMap {
         let reader: BufReader<Box<dyn Read>> = BufReader::new(if filename == "-" {
             Box::new(stdin())
         } else {
-            let file = crash_if_err!(1, File::open(filename));
+            let file = File::open(filename)?;
             Box::new(file)
         });
-        let lines: Vec<String> = reader.lines().map(|x| crash_if_err!(1, x)).collect();
+        let lines: Vec<String> = reader.lines().collect::<std::io::Result<Vec<String>>>()?;
 
         // Indexing UTF-8 string requires walking from the beginning, which can hurts performance badly when the line is long.
         // Since we will be jumping around the line a lot, we dump the content into a Vec<char>, which can be indexed in constant time.
@@ -241,9 +277,9 @@ fn read_input(input_files: &[String], config: &Config) -> FileMap {
                 offset,
             },
         );
-        offset += size
+        offset += size;
     }
-    file_map
+    Ok(file_map)
 }
 
 /// Go through every lines in the input files and record each match occurrence as a `WordRef`.
@@ -526,7 +562,7 @@ fn format_tex_line(
 }
 
 fn format_roff_field(s: &str) -> String {
-    s.replace("\"", "\"\"")
+    s.replace('\"', "\"\"")
 }
 
 fn format_roff_line(
@@ -571,11 +607,11 @@ fn write_traditional_output(
     file_map: &FileMap,
     words: &BTreeSet<WordRef>,
     output_filename: &str,
-) {
+) -> UResult<()> {
     let mut writer: BufWriter<Box<dyn Write>> = BufWriter::new(if output_filename == "-" {
         Box::new(stdout())
     } else {
-        let file = crash_if_err!(1, File::create(output_filename));
+        let file = File::create(output_filename).map_err_context(String::new)?;
         Box::new(file)
     });
 
@@ -611,10 +647,13 @@ fn write_traditional_output(
                 &chars_lines[word_ref.local_line_nr],
                 &reference,
             ),
-            OutFormat::Dumb => crash!(1, "There is no dumb format with GNU extensions disabled"),
+            OutFormat::Dumb => {
+                return Err(PtxError::DumbFormat.into());
+            }
         };
-        crash_if_err!(1, writeln!(writer, "{}", output_line));
+        writeln!(writer, "{}", output_line).map_err_context(String::new)?;
     }
+    Ok(())
 }
 
 mod options {
@@ -637,7 +676,8 @@ mod options {
     pub static WIDTH: &str = "width";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
@@ -645,144 +685,149 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     // let mut opts = Options::new();
     let matches = uu_app().get_matches_from(args);
 
-    let input_files: Vec<String> = match &matches.values_of(options::FILE) {
+    let mut input_files: Vec<String> = match &matches.values_of(options::FILE) {
         Some(v) => v.clone().map(|v| v.to_owned()).collect(),
         None => vec!["-".to_string()],
     };
 
-    let config = get_config(&matches);
-    let word_filter = WordFilter::new(&matches, &config);
-    let file_map = read_input(&input_files, &config);
+    let config = get_config(&matches)?;
+    let word_filter = WordFilter::new(&matches, &config)?;
+    let file_map = read_input(&input_files, &config).map_err_context(String::new)?;
     let word_set = create_word_set(&config, &word_filter, &file_map);
-    let output_file = if !config.gnu_ext && matches.args.len() == 2 {
-        matches.value_of(options::FILE).unwrap_or("-").to_string()
+    let output_file = if !config.gnu_ext && input_files.len() == 2 {
+        input_files.pop().unwrap()
     } else {
-        "-".to_owned()
+        "-".to_string()
     };
-    write_traditional_output(&config, &file_map, &word_set, &output_file);
-    0
+    write_traditional_output(&config, &file_map, &word_set, &output_file)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
+        .about(ABOUT)
         .version(crate_version!())
-        .usage(BRIEF)
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::AUTO_REFERENCE)
-                .short("A")
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
+        .arg(
+            Arg::new(options::AUTO_REFERENCE)
+                .short('A')
                 .long(options::AUTO_REFERENCE)
                 .help("output automatically generated references")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::TRADITIONAL)
-                .short("G")
+            Arg::new(options::TRADITIONAL)
+                .short('G')
                 .long(options::TRADITIONAL)
                 .help("behave more like System V 'ptx'"),
         )
         .arg(
-            Arg::with_name(options::FLAG_TRUNCATION)
-                .short("F")
+            Arg::new(options::FLAG_TRUNCATION)
+                .short('F')
                 .long(options::FLAG_TRUNCATION)
                 .help("use STRING for flagging line truncations")
                 .value_name("STRING")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::MACRO_NAME)
-                .short("M")
+            Arg::new(options::MACRO_NAME)
+                .short('M')
                 .long(options::MACRO_NAME)
                 .help("macro name to use instead of 'xx'")
                 .value_name("STRING")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::FORMAT_ROFF)
-                .short("O")
+            Arg::new(options::FORMAT_ROFF)
+                .short('O')
                 .long(options::FORMAT_ROFF)
                 .help("generate output as roff directives"),
         )
         .arg(
-            Arg::with_name(options::RIGHT_SIDE_REFS)
-                .short("R")
+            Arg::new(options::RIGHT_SIDE_REFS)
+                .short('R')
                 .long(options::RIGHT_SIDE_REFS)
                 .help("put references at right, not counted in -w")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::SENTENCE_REGEXP)
-                .short("S")
+            Arg::new(options::SENTENCE_REGEXP)
+                .short('S')
                 .long(options::SENTENCE_REGEXP)
                 .help("for end of lines or end of sentences")
                 .value_name("REGEXP")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::FORMAT_TEX)
-                .short("T")
+            Arg::new(options::FORMAT_TEX)
+                .short('T')
                 .long(options::FORMAT_TEX)
                 .help("generate output as TeX directives"),
         )
         .arg(
-            Arg::with_name(options::WORD_REGEXP)
-                .short("W")
+            Arg::new(options::WORD_REGEXP)
+                .short('W')
                 .long(options::WORD_REGEXP)
                 .help("use REGEXP to match each keyword")
                 .value_name("REGEXP")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::BREAK_FILE)
-                .short("b")
+            Arg::new(options::BREAK_FILE)
+                .short('b')
                 .long(options::BREAK_FILE)
                 .help("word break characters in this FILE")
                 .value_name("FILE")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::IGNORE_CASE)
-                .short("f")
+            Arg::new(options::IGNORE_CASE)
+                .short('f')
                 .long(options::IGNORE_CASE)
                 .help("fold lower case to upper case for sorting")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::GAP_SIZE)
-                .short("g")
+            Arg::new(options::GAP_SIZE)
+                .short('g')
                 .long(options::GAP_SIZE)
                 .help("gap size in columns between output fields")
                 .value_name("NUMBER")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::IGNORE_FILE)
-                .short("i")
+            Arg::new(options::IGNORE_FILE)
+                .short('i')
                 .long(options::IGNORE_FILE)
                 .help("read ignore word list from FILE")
                 .value_name("FILE")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::ONLY_FILE)
-                .short("o")
+            Arg::new(options::ONLY_FILE)
+                .short('o')
                 .long(options::ONLY_FILE)
                 .help("read only word list from this FILE")
                 .value_name("FILE")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::REFERENCES)
-                .short("r")
+            Arg::new(options::REFERENCES)
+                .short('r')
                 .long(options::REFERENCES)
                 .help("first field of each line is a reference")
                 .value_name("FILE")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::WIDTH)
-                .short("w")
+            Arg::new(options::WIDTH)
+                .short('w')
                 .long(options::WIDTH)
                 .help("output width in columns, reference excluded")
                 .value_name("NUMBER")
diff --git a/src/uu/pwd/Cargo.toml b/src/uu/pwd/Cargo.toml
index a168fb5aa..d045d6179 100644
--- a/src/uu/pwd/Cargo.toml
+++ b/src/uu/pwd/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_pwd"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "pwd ~ (uutils) display current working directory"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/pwd"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pwd"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/pwd.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "pwd"
diff --git a/src/uu/pwd/LICENSE b/src/uu/pwd/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/pwd/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/pwd/src/main.rs b/src/uu/pwd/src/main.rs
index c5716d2c9..710a9b230 100644
--- a/src/uu/pwd/src/main.rs
+++ b/src/uu/pwd/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_pwd);
+uucore::bin!(uu_pwd);
diff --git a/src/uu/pwd/src/pwd.rs b/src/uu/pwd/src/pwd.rs
index 8beb65dbd..67462ac16 100644
--- a/src/uu/pwd/src/pwd.rs
+++ b/src/uu/pwd/src/pwd.rs
@@ -5,20 +5,22 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::env;
 use std::io;
 use std::path::PathBuf;
+use uucore::format_usage;
 
 use uucore::display::println_verbatim;
 use uucore::error::{FromIo, UResult};
 
 static ABOUT: &str = "Display the full filename of the current working directory.";
+const USAGE: &str = "{} [OPTION]... FILE...";
 static OPT_LOGICAL: &str = "logical";
 static OPT_PHYSICAL: &str = "physical";
 
 fn physical_path() -> io::Result<PathBuf> {
-    // std::env::current_dir() is a thin wrapper around libc's getcwd().
+    // std::env::current_dir() is a thin wrapper around libc::getcwd().
 
     // On Unix, getcwd() must return the physical path:
     // https://pubs.opengroup.org/onlinepubs/9699919799/functions/getcwd.html
@@ -120,15 +122,9 @@ fn logical_path() -> io::Result<PathBuf> {
     }
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... FILE...", uucore::execution_phrase())
-}
-
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
     let cwd = if matches.is_present(OPT_LOGICAL) {
         logical_path()
     } else {
@@ -152,19 +148,21 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_LOGICAL)
-                .short("L")
+            Arg::new(OPT_LOGICAL)
+                .short('L')
                 .long(OPT_LOGICAL)
                 .help("use PWD from environment, even if it contains symlinks"),
         )
         .arg(
-            Arg::with_name(OPT_PHYSICAL)
-                .short("P")
+            Arg::new(OPT_PHYSICAL)
+                .short('P')
                 .long(OPT_PHYSICAL)
                 .overrides_with(OPT_LOGICAL)
                 .help("avoid all symlinks"),
diff --git a/src/uu/readlink/Cargo.toml b/src/uu/readlink/Cargo.toml
index d126a3835..5a2e42004 100644
--- a/src/uu/readlink/Cargo.toml
+++ b/src/uu/readlink/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_readlink"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "readlink ~ (uutils) display resolved path of PATHNAME"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/readlink"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/readlink"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,9 @@ edition = "2018"
 path = "src/readlink.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "readlink"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/readlink/LICENSE b/src/uu/readlink/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/readlink/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/readlink/src/main.rs b/src/uu/readlink/src/main.rs
index 651fd73ca..57d5988f7 100644
--- a/src/uu/readlink/src/main.rs
+++ b/src/uu/readlink/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_readlink);
+uucore::bin!(uu_readlink);
diff --git a/src/uu/readlink/src/readlink.rs b/src/uu/readlink/src/readlink.rs
index d6dd1634a..ba1e368f2 100644
--- a/src/uu/readlink/src/readlink.rs
+++ b/src/uu/readlink/src/readlink.rs
@@ -10,14 +10,17 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs;
 use std::io::{stdout, Write};
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::format_usage;
 use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
 
 const ABOUT: &str = "Print value of a symbolic link or canonical file name.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 const OPT_CANONICALIZE: &str = "canonicalize";
 const OPT_CANONICALIZE_MISSING: &str = "canonicalize-missing";
 const OPT_CANONICALIZE_EXISTING: &str = "canonicalize-existing";
@@ -29,13 +32,9 @@ const OPT_ZERO: &str = "zero";
 
 const ARG_FILES: &str = "files";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let mut no_newline = matches.is_present(OPT_NO_NEWLINE);
     let use_zero = matches.is_present(OPT_ZERO);
@@ -64,11 +63,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         .map(|v| v.map(ToString::to_string).collect())
         .unwrap_or_default();
     if files.is_empty() {
-        crash!(
-            1,
-            "missing operand\nTry '{} --help' for more information",
-            uucore::execution_phrase()
-        );
+        return Err(UUsageError::new(1, "missing operand"));
     }
 
     if no_newline && files.len() > 1 && !silent {
@@ -78,39 +73,37 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     for f in &files {
         let p = PathBuf::from(f);
-        if res_mode == ResolveMode::None {
-            match fs::read_link(&p) {
-                Ok(path) => show(&path, no_newline, use_zero),
-                Err(err) => {
-                    if verbose {
-                        show_error!("{}: errno {}", f.maybe_quote(), err.raw_os_error().unwrap());
-                    }
-                    return 1;
-                }
-            }
+        let path_result = if res_mode == ResolveMode::None {
+            fs::read_link(&p)
         } else {
-            match canonicalize(&p, can_mode, res_mode) {
-                Ok(path) => show(&path, no_newline, use_zero),
-                Err(err) => {
-                    if verbose {
-                        show_error!("{}: errno {}", f.maybe_quote(), err.raw_os_error().unwrap());
-                    }
-                    return 1;
+            canonicalize(&p, can_mode, res_mode)
+        };
+        match path_result {
+            Ok(path) => show(&path, no_newline, use_zero).map_err_context(String::new)?,
+            Err(err) => {
+                if verbose {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("{}: errno {}", f.maybe_quote(), err.raw_os_error().unwrap()),
+                    ));
+                } else {
+                    return Err(1.into());
                 }
             }
         }
     }
-
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_help(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_CANONICALIZE)
-                .short("f")
+            Arg::new(OPT_CANONICALIZE)
+                .short('f')
                 .long(OPT_CANONICALIZE)
                 .help(
                     "canonicalize by following every symlink in every component of the \
@@ -118,8 +111,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_CANONICALIZE_EXISTING)
-                .short("e")
+            Arg::new(OPT_CANONICALIZE_EXISTING)
+                .short('e')
                 .long("canonicalize-existing")
                 .help(
                     "canonicalize by following every symlink in every component of the \
@@ -127,8 +120,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_CANONICALIZE_MISSING)
-                .short("m")
+            Arg::new(OPT_CANONICALIZE_MISSING)
+                .short('m')
                 .long(OPT_CANONICALIZE_MISSING)
                 .help(
                     "canonicalize by following every symlink in every component of the \
@@ -136,39 +129,43 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_NO_NEWLINE)
-                .short("n")
+            Arg::new(OPT_NO_NEWLINE)
+                .short('n')
                 .long(OPT_NO_NEWLINE)
                 .help("do not output the trailing delimiter"),
         )
         .arg(
-            Arg::with_name(OPT_QUIET)
-                .short("q")
+            Arg::new(OPT_QUIET)
+                .short('q')
                 .long(OPT_QUIET)
                 .help("suppress most error messages"),
         )
         .arg(
-            Arg::with_name(OPT_SILENT)
-                .short("s")
+            Arg::new(OPT_SILENT)
+                .short('s')
                 .long(OPT_SILENT)
                 .help("suppress most error messages"),
         )
         .arg(
-            Arg::with_name(OPT_VERBOSE)
-                .short("v")
+            Arg::new(OPT_VERBOSE)
+                .short('v')
                 .long(OPT_VERBOSE)
                 .help("report error message"),
         )
         .arg(
-            Arg::with_name(OPT_ZERO)
-                .short("z")
+            Arg::new(OPT_ZERO)
+                .short('z')
                 .long(OPT_ZERO)
                 .help("separate output with NUL rather than newline"),
         )
-        .arg(Arg::with_name(ARG_FILES).multiple(true).takes_value(true))
+        .arg(
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
+                .takes_value(true),
+        )
 }
 
-fn show(path: &Path, no_newline: bool, use_zero: bool) {
+fn show(path: &Path, no_newline: bool, use_zero: bool) -> std::io::Result<()> {
     let path = path.to_str().unwrap();
     if use_zero {
         print!("{}\0", path);
@@ -177,5 +174,5 @@ fn show(path: &Path, no_newline: bool, use_zero: bool) {
     } else {
         println!("{}", path);
     }
-    crash_if_err!(1, stdout().flush());
+    stdout().flush()
 }
diff --git a/src/uu/realpath/Cargo.toml b/src/uu/realpath/Cargo.toml
index 4be39f978..77d8ccacb 100644
--- a/src/uu/realpath/Cargo.toml
+++ b/src/uu/realpath/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_realpath"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "realpath ~ (uutils) display resolved absolute path of PATHNAME"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/realpath"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/realpath"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/realpath.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "realpath"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/realpath/LICENSE b/src/uu/realpath/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/realpath/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/realpath/src/main.rs b/src/uu/realpath/src/main.rs
index 8b8a8dc5e..0d7e188d1 100644
--- a/src/uu/realpath/src/main.rs
+++ b/src/uu/realpath/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_realpath);
+uucore::bin!(uu_realpath);
diff --git a/src/uu/realpath/src/realpath.rs b/src/uu/realpath/src/realpath.rs
index d13aed6c7..bea89c19e 100644
--- a/src/uu/realpath/src/realpath.rs
+++ b/src/uu/realpath/src/realpath.rs
@@ -10,17 +10,20 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::{
     io::{stdout, Write},
     path::{Path, PathBuf},
 };
 use uucore::{
     display::{print_verbatim, Quotable},
+    error::{FromIo, UResult},
+    format_usage,
     fs::{canonicalize, MissingHandling, ResolveMode},
 };
 
 static ABOUT: &str = "print the resolved path";
+const USAGE: &str = "{} [OPTION]... FILE...";
 
 static OPT_QUIET: &str = "quiet";
 static OPT_STRIP: &str = "strip";
@@ -32,14 +35,9 @@ const OPT_CANONICALIZE_EXISTING: &str = "canonicalize-existing";
 
 static ARG_FILES: &str = "files";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... FILE...", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     /*  the list of files */
 
@@ -60,56 +58,58 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     } else {
         MissingHandling::Normal
     };
-    let mut retcode = 0;
     for path in &paths {
-        if let Err(e) = resolve_path(path, strip, zero, logical, can_mode) {
-            if !quiet {
-                show_error!("{}: {}", path.maybe_quote(), e);
-            }
-            retcode = 1
-        };
+        let result = resolve_path(path, strip, zero, logical, can_mode);
+        if !quiet {
+            show_if_err!(result.map_err_context(|| path.maybe_quote().to_string()));
+        }
     }
-    retcode
+    // Although we return `Ok`, it is possible that a call to
+    // `show!()` above has set the exit code for the program to a
+    // non-zero integer.
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_QUIET)
-                .short("q")
+            Arg::new(OPT_QUIET)
+                .short('q')
                 .long(OPT_QUIET)
                 .help("Do not print warnings for invalid paths"),
         )
         .arg(
-            Arg::with_name(OPT_STRIP)
-                .short("s")
+            Arg::new(OPT_STRIP)
+                .short('s')
                 .long(OPT_STRIP)
                 .help("Only strip '.' and '..' components, but don't resolve symbolic links"),
         )
         .arg(
-            Arg::with_name(OPT_ZERO)
-                .short("z")
+            Arg::new(OPT_ZERO)
+                .short('z')
                 .long(OPT_ZERO)
                 .help("Separate output filenames with \\0 rather than newline"),
         )
         .arg(
-            Arg::with_name(OPT_LOGICAL)
-                .short("L")
+            Arg::new(OPT_LOGICAL)
+                .short('L')
                 .long(OPT_LOGICAL)
                 .help("resolve '..' components before symlinks"),
         )
         .arg(
-            Arg::with_name(OPT_PHYSICAL)
-                .short("P")
+            Arg::new(OPT_PHYSICAL)
+                .short('P')
                 .long(OPT_PHYSICAL)
                 .overrides_with_all(&[OPT_STRIP, OPT_LOGICAL])
                 .help("resolve symlinks as encountered (default)"),
         )
         .arg(
-            Arg::with_name(OPT_CANONICALIZE_EXISTING)
-                .short("e")
+            Arg::new(OPT_CANONICALIZE_EXISTING)
+                .short('e')
                 .long(OPT_CANONICALIZE_EXISTING)
                 .help(
                     "canonicalize by following every symlink in every component of the \
@@ -117,8 +117,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(OPT_CANONICALIZE_MISSING)
-                .short("m")
+            Arg::new(OPT_CANONICALIZE_MISSING)
+                .short('m')
                 .long(OPT_CANONICALIZE_MISSING)
                 .help(
                     "canonicalize by following every symlink in every component of the \
@@ -126,8 +126,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(ARG_FILES)
-                .multiple(true)
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .required(true)
                 .min_values(1),
diff --git a/src/uu/relpath/Cargo.toml b/src/uu/relpath/Cargo.toml
index f1ddf87dc..4ac8ca0cd 100644
--- a/src/uu/relpath/Cargo.toml
+++ b/src/uu/relpath/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_relpath"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "relpath ~ (uutils) display relative path of PATHNAME_TO from PATHNAME_FROM"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/relpath"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/relpath"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/relpath.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "relpath"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/relpath/LICENSE b/src/uu/relpath/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/relpath/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/relpath/src/main.rs b/src/uu/relpath/src/main.rs
index 22aa68d53..b7dba76ce 100644
--- a/src/uu/relpath/src/main.rs
+++ b/src/uu/relpath/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_relpath);
+uucore::bin!(uu_relpath);
diff --git a/src/uu/relpath/src/relpath.rs b/src/uu/relpath/src/relpath.rs
index 16b920861..2e45ce927 100644
--- a/src/uu/relpath/src/relpath.rs
+++ b/src/uu/relpath/src/relpath.rs
@@ -7,15 +7,17 @@
 
 // spell-checker:ignore (ToDO) subpath absto absfrom absbase
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::env;
 use std::path::{Path, PathBuf};
 use uucore::display::println_verbatim;
+use uucore::error::{FromIo, UResult};
 use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "Convert TO destination to the relative path from the FROM dir.
 If FROM path is omitted, current working dir will be used.";
+const USAGE: &str = "{} [-d DIR] TO [FROM]";
 
 mod options {
     pub const DIR: &str = "DIR";
@@ -23,34 +25,32 @@ mod options {
     pub const FROM: &str = "FROM";
 }
 
-fn usage() -> String {
-    format!("{} [-d DIR] TO [FROM]", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
-    let usage = usage();
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     let to = Path::new(matches.value_of(options::TO).unwrap()).to_path_buf(); // required
     let from = match matches.value_of(options::FROM) {
         Some(p) => Path::new(p).to_path_buf(),
         None => env::current_dir().unwrap(),
     };
-    let absto = canonicalize(to, MissingHandling::Normal, ResolveMode::Logical).unwrap();
-    let absfrom = canonicalize(from, MissingHandling::Normal, ResolveMode::Logical).unwrap();
+    let absto = canonicalize(to, MissingHandling::Normal, ResolveMode::Logical)
+        .map_err_context(String::new)?;
+    let absfrom = canonicalize(from, MissingHandling::Normal, ResolveMode::Logical)
+        .map_err_context(String::new)?;
 
     if matches.is_present(options::DIR) {
         let base = Path::new(&matches.value_of(options::DIR).unwrap()).to_path_buf();
-        let absbase = canonicalize(base, MissingHandling::Normal, ResolveMode::Logical).unwrap();
+        let absbase = canonicalize(base, MissingHandling::Normal, ResolveMode::Logical)
+            .map_err_context(String::new)?;
         if !absto.as_path().starts_with(absbase.as_path())
             || !absfrom.as_path().starts_with(absbase.as_path())
         {
-            println_verbatim(absto).unwrap();
-            return 0;
+            return println_verbatim(absto).map_err_context(String::new);
         }
     }
 
@@ -75,27 +75,18 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         .map(|x| result.push(x.as_os_str()))
         .last();
 
-    println_verbatim(result).unwrap();
-    0
+    println_verbatim(result).map_err_context(String::new)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .arg(
-            Arg::with_name(options::DIR)
-                .short("d")
-                .takes_value(true)
-                .help("If any of FROM and TO is not subpath of DIR, output absolute path instead of relative"),
-        )
-        .arg(
-            Arg::with_name(options::TO)
-                .required(true)
-                .takes_value(true),
-        )
-        .arg(
-            Arg::with_name(options::FROM)
-                .takes_value(true),
-        )
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .arg(Arg::new(options::DIR).short('d').takes_value(true).help(
+            "If any of FROM and TO is not subpath of DIR, output absolute path instead of relative",
+        ))
+        .arg(Arg::new(options::TO).required(true).takes_value(true))
+        .arg(Arg::new(options::FROM).takes_value(true))
 }
diff --git a/src/uu/rm/Cargo.toml b/src/uu/rm/Cargo.toml
index 757fa8b22..adef3eeab 100644
--- a/src/uu/rm/Cargo.toml
+++ b/src/uu/rm/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_rm"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "rm ~ (uutils) remove PATHNAME"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/rm"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/rm"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,10 @@ edition = "2018"
 path = "src/rm.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 walkdir = "2.2"
 remove_dir_all = "0.5.1"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version="0.3", features=[] }
@@ -27,7 +26,3 @@ winapi = { version="0.3", features=[] }
 [[bin]]
 name = "rm"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/rm/LICENSE b/src/uu/rm/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/rm/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/rm/src/main.rs b/src/uu/rm/src/main.rs
index 960867359..966365137 100644
--- a/src/uu/rm/src/main.rs
+++ b/src/uu/rm/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_rm);
+uucore::bin!(uu_rm);
diff --git a/src/uu/rm/src/rm.rs b/src/uu/rm/src/rm.rs
index 54fce52ff..0701387d9 100644
--- a/src/uu/rm/src/rm.rs
+++ b/src/uu/rm/src/rm.rs
@@ -10,7 +10,7 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use remove_dir_all::remove_dir_all;
 use std::collections::VecDeque;
 use std::fs;
@@ -18,11 +18,13 @@ use std::io::{stderr, stdin, BufRead, Write};
 use std::ops::BitOr;
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
+use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::format_usage;
 use walkdir::{DirEntry, WalkDir};
 
 #[derive(Eq, PartialEq, Clone, Copy)]
 enum InteractiveMode {
-    None,
+    Never,
     Once,
     Always,
 }
@@ -39,6 +41,7 @@ struct Options {
 }
 
 static ABOUT: &str = "Remove (unlink) the FILE(s)";
+const USAGE: &str = "{} [OPTION]... FILE...";
 static OPT_DIR: &str = "dir";
 static OPT_INTERACTIVE: &str = "interactive";
 static OPT_FORCE: &str = "force";
@@ -50,13 +53,10 @@ static OPT_PROMPT_MORE: &str = "prompt-more";
 static OPT_RECURSIVE: &str = "recursive";
 static OPT_RECURSIVE_R: &str = "recursive_R";
 static OPT_VERBOSE: &str = "verbose";
+static PRESUME_INPUT_TTY: &str = "-presume-input-tty";
 
 static ARG_FILES: &str = "files";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... FILE...", uucore::execution_phrase())
-}
-
 fn get_long_usage() -> String {
     String::from(
         "By default, rm does not remove directories.  Use the --recursive (-r or -R)
@@ -74,14 +74,11 @@ fn get_long_usage() -> String {
     )
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let long_usage = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&long_usage[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&long_usage[..]).get_matches_from(args);
 
     let files: Vec<String> = matches
         .values_of(ARG_FILES)
@@ -93,9 +90,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     if files.is_empty() && !force {
         // Still check by hand and not use clap
         // Because "rm -f" is a thing
-        show_error!("missing an argument");
-        show_error!("for help, try '{0} --help'", uucore::execution_phrase());
-        return 1;
+        return Err(UUsageError::new(1, "missing operand"));
     } else {
         let options = Options {
             force,
@@ -106,13 +101,18 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                     InteractiveMode::Once
                 } else if matches.is_present(OPT_INTERACTIVE) {
                     match matches.value_of(OPT_INTERACTIVE).unwrap() {
-                        "none" => InteractiveMode::None,
+                        "never" => InteractiveMode::Never,
                         "once" => InteractiveMode::Once,
                         "always" => InteractiveMode::Always,
-                        val => crash!(1, "Invalid argument to interactive ({})", val),
+                        val => {
+                            return Err(USimpleError::new(
+                                1,
+                                format!("Invalid argument to interactive ({})", val),
+                            ))
+                        }
                     }
                 } else {
-                    InteractiveMode::None
+                    InteractiveMode::Never
                 }
             },
             one_fs: matches.is_present(OPT_ONE_FILE_SYSTEM),
@@ -128,107 +128,122 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                 "Remove all arguments? "
             };
             if !prompt(msg) {
-                return 0;
+                return Ok(());
             }
         }
 
-        if remove(files, options) {
-            return 1;
+        if remove(&files, &options) {
+            return Err(1.into());
         }
     }
-
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_FORCE)
-            .short("f")
+            Arg::new(OPT_FORCE)
+            .short('f')
             .long(OPT_FORCE)
-            .multiple(true)
+            .multiple_occurrences(true)
             .help("ignore nonexistent files and arguments, never prompt")
         )
         .arg(
-            Arg::with_name(OPT_PROMPT)
-            .short("i")
+            Arg::new(OPT_PROMPT)
+            .short('i')
             .long("prompt before every removal")
         )
         .arg(
-            Arg::with_name(OPT_PROMPT_MORE)
-            .short("I")
+            Arg::new(OPT_PROMPT_MORE)
+            .short('I')
             .help("prompt once before removing more than three files, or when removing recursively. Less intrusive than -i, while still giving some protection against most mistakes")
         )
         .arg(
-            Arg::with_name(OPT_INTERACTIVE)
+            Arg::new(OPT_INTERACTIVE)
             .long(OPT_INTERACTIVE)
             .help("prompt according to WHEN: never, once (-I), or always (-i). Without WHEN, prompts always")
             .value_name("WHEN")
             .takes_value(true)
         )
         .arg(
-            Arg::with_name(OPT_ONE_FILE_SYSTEM)
+            Arg::new(OPT_ONE_FILE_SYSTEM)
             .long(OPT_ONE_FILE_SYSTEM)
             .help("when removing a hierarchy recursively, skip any directory that is on a file system different from that of the corresponding command line argument (NOT IMPLEMENTED)")
         )
         .arg(
-            Arg::with_name(OPT_NO_PRESERVE_ROOT)
+            Arg::new(OPT_NO_PRESERVE_ROOT)
             .long(OPT_NO_PRESERVE_ROOT)
             .help("do not treat '/' specially")
         )
         .arg(
-            Arg::with_name(OPT_PRESERVE_ROOT)
+            Arg::new(OPT_PRESERVE_ROOT)
             .long(OPT_PRESERVE_ROOT)
             .help("do not remove '/' (default)")
         )
         .arg(
-            Arg::with_name(OPT_RECURSIVE).short("r")
+            Arg::new(OPT_RECURSIVE).short('r')
+            .multiple_occurrences(true)
             .long(OPT_RECURSIVE)
             .help("remove directories and their contents recursively")
         )
         .arg(
             // To mimic GNU's behavior we also want the '-R' flag. However, using clap's
             // alias method 'visible_alias("R")' would result in a long '--R' flag.
-            Arg::with_name(OPT_RECURSIVE_R).short("R")
+            Arg::new(OPT_RECURSIVE_R).short('R')
             .help("Equivalent to -r")
         )
         .arg(
-            Arg::with_name(OPT_DIR)
-            .short("d")
+            Arg::new(OPT_DIR)
+            .short('d')
             .long(OPT_DIR)
             .help("remove empty directories")
         )
         .arg(
-            Arg::with_name(OPT_VERBOSE)
-            .short("v")
+            Arg::new(OPT_VERBOSE)
+            .short('v')
             .long(OPT_VERBOSE)
             .help("explain what is being done")
         )
+        // From the GNU source code:
+        // This is solely for testing.
+        // Do not document.
+        // It is relatively difficult to ensure that there is a tty on stdin.
+        // Since rm acts differently depending on that, without this option,
+        // it'd be harder to test the parts of rm that depend on that setting.
+        // In contrast with Arg::long, Arg::alias does not strip leading
+        // hyphens. Therefore it supports 3 leading hyphens.
         .arg(
-            Arg::with_name(ARG_FILES)
-            .multiple(true)
+            Arg::new(PRESUME_INPUT_TTY)
+            .long(PRESUME_INPUT_TTY)
+            .alias(PRESUME_INPUT_TTY)
+            .hide(true)
+        )
+        .arg(
+            Arg::new(ARG_FILES)
+            .multiple_occurrences(true)
             .takes_value(true)
             .min_values(1)
         )
 }
 
 // TODO: implement one-file-system (this may get partially implemented in walkdir)
-fn remove(files: Vec<String>, options: Options) -> bool {
+fn remove(files: &[String], options: &Options) -> bool {
     let mut had_err = false;
 
-    for filename in &files {
+    for filename in files {
         let file = Path::new(filename);
         had_err = match file.symlink_metadata() {
             Ok(metadata) => {
                 if metadata.is_dir() {
-                    handle_dir(file, &options)
+                    handle_dir(file, options)
                 } else if is_symlink_dir(&metadata) {
-                    remove_dir(file, &options)
+                    remove_dir(file, options)
                 } else {
-                    remove_file(file, &options)
+                    remove_file(file, options)
                 }
             }
             Err(_e) => {
diff --git a/src/uu/rmdir/Cargo.toml b/src/uu/rmdir/Cargo.toml
index bc05773a8..34ad36819 100644
--- a/src/uu/rmdir/Cargo.toml
+++ b/src/uu/rmdir/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_rmdir"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "rmdir ~ (uutils) remove empty DIRECTORY"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/rmdir"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/rmdir"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/rmdir.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-libc = "0.2.42"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
+libc = "0.2.121"
 
 [[bin]]
 name = "rmdir"
diff --git a/src/uu/rmdir/LICENSE b/src/uu/rmdir/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/rmdir/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/rmdir/src/main.rs b/src/uu/rmdir/src/main.rs
index 92ff22c07..b10f0ade8 100644
--- a/src/uu/rmdir/src/main.rs
+++ b/src/uu/rmdir/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_rmdir);
+uucore::bin!(uu_rmdir);
diff --git a/src/uu/rmdir/src/rmdir.rs b/src/uu/rmdir/src/rmdir.rs
index f982cf4c3..127b8fcf9 100644
--- a/src/uu/rmdir/src/rmdir.rs
+++ b/src/uu/rmdir/src/rmdir.rs
@@ -10,30 +10,25 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::{read_dir, remove_dir};
 use std::io;
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{set_exit_code, strip_errno, UResult};
-use uucore::util_name;
+use uucore::{format_usage, util_name};
 
 static ABOUT: &str = "Remove the DIRECTORY(ies), if they are empty.";
+const USAGE: &str = "{} [OPTION]... DIRECTORY...";
 static OPT_IGNORE_FAIL_NON_EMPTY: &str = "ignore-fail-on-non-empty";
 static OPT_PARENTS: &str = "parents";
 static OPT_VERBOSE: &str = "verbose";
 
 static ARG_DIRS: &str = "dirs";
 
-fn usage() -> String {
-    format!("{0} [OPTION]... DIRECTORY...", uucore::execution_phrase())
-}
-
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     let opts = Opts {
         ignore: matches.is_present(OPT_IGNORE_FAIL_NON_EMPTY),
@@ -175,35 +170,33 @@ struct Opts {
     verbose: bool,
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(OPT_IGNORE_FAIL_NON_EMPTY)
+            Arg::new(OPT_IGNORE_FAIL_NON_EMPTY)
                 .long(OPT_IGNORE_FAIL_NON_EMPTY)
                 .help("ignore each failure that is solely because a directory is non-empty"),
         )
-        .arg(
-            Arg::with_name(OPT_PARENTS)
-                .short("p")
-                .long(OPT_PARENTS)
-                .help(
-                    "remove DIRECTORY and its ancestors; e.g.,
+        .arg(Arg::new(OPT_PARENTS).short('p').long(OPT_PARENTS).help(
+            "remove DIRECTORY and its ancestors; e.g.,
                   'rmdir -p a/b/c' is similar to rmdir a/b/c a/b a",
-                ),
-        )
+        ))
         .arg(
-            Arg::with_name(OPT_VERBOSE)
-                .short("v")
+            Arg::new(OPT_VERBOSE)
+                .short('v')
                 .long(OPT_VERBOSE)
                 .help("output a diagnostic for every directory processed"),
         )
         .arg(
-            Arg::with_name(ARG_DIRS)
-                .multiple(true)
+            Arg::new(ARG_DIRS)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .min_values(1)
-                .required(true),
+                .required(true)
+                .allow_invalid_utf8(true),
         )
 }
diff --git a/src/uu/runcon/Cargo.toml b/src/uu/runcon/Cargo.toml
index ff06e72a1..4cce3c504 100644
--- a/src/uu/runcon/Cargo.toml
+++ b/src/uu/runcon/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
 name = "uu_runcon"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "runcon ~ (uutils) run command with specified security context"
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/runcon"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/runcon"
 keywords = ["coreutils", "uutils", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -14,11 +14,9 @@ edition = "2018"
 path = "src/runcon.rs"
 
 [dependencies]
-clap         = { version = "2.33", features = ["wrap_help"] }
+clap         = { version = "3.1", features = ["wrap_help", "cargo"] }
 uucore       = { version = ">=0.0.9", package="uucore", path="../../uucore", features=["entries", "fs", "perms"] }
-uucore_procs = { version = ">=0.0.6", package="uucore_procs", path="../../uucore_procs" }
 selinux      = { version = "0.2"   }
-fts-sys      = { version = "0.2"   }
 thiserror    = { version = "1.0"   }
 libc         = { version = "0.2"   }
 
diff --git a/src/uu/runcon/LICENSE b/src/uu/runcon/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/runcon/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/runcon/src/errors.rs b/src/uu/runcon/src/errors.rs
index 5f8258de0..18f06deb9 100644
--- a/src/uu/runcon/src/errors.rs
+++ b/src/uu/runcon/src/errors.rs
@@ -1,12 +1,22 @@
 use std::ffi::OsString;
-use std::fmt::Write;
+use std::fmt::{Display, Formatter, Write};
 use std::io;
 use std::str::Utf8Error;
 
 use uucore::display::Quotable;
+use uucore::error::UError;
 
 pub(crate) type Result<T> = std::result::Result<T, Error>;
 
+// This list is NOT exhaustive. This command might perform an `execvp()` to run
+// a different program. When that happens successfully, the exit status of this
+// process will be the exit status of that program.
+pub(crate) mod error_exit_status {
+    pub const NOT_FOUND: i32 = 127;
+    pub const COULD_NOT_EXECUTE: i32 = 126;
+    pub const ANOTHER_ERROR: i32 = libc::EXIT_FAILURE;
+}
+
 #[derive(thiserror::Error, Debug)]
 pub(crate) enum Error {
     #[error("No command is specified")]
@@ -63,13 +73,44 @@ impl Error {
     }
 }
 
-pub(crate) fn report_full_error(mut err: &dyn std::error::Error) -> String {
-    let mut desc = String::with_capacity(256);
-    write!(&mut desc, "{}", err).unwrap();
+pub(crate) fn write_full_error<W>(writer: &mut W, err: &dyn std::error::Error) -> std::fmt::Result
+where
+    W: Write,
+{
+    write!(writer, "{}", err)?;
+    let mut err = err;
     while let Some(source) = err.source() {
         err = source;
-        write!(&mut desc, ": {}", err).unwrap();
+        write!(writer, ": {}", err)?;
+    }
+    write!(writer, ".")?;
+    Ok(())
+}
+
+#[derive(Debug)]
+pub(crate) struct RunconError {
+    inner: Error,
+    code: i32,
+}
+
+impl RunconError {
+    pub(crate) fn new(e: Error) -> Self {
+        Self::with_code(error_exit_status::ANOTHER_ERROR, e)
+    }
+
+    pub(crate) fn with_code(code: i32, e: Error) -> Self {
+        Self { inner: e, code }
+    }
+}
+
+impl std::error::Error for RunconError {}
+impl UError for RunconError {
+    fn code(&self) -> i32 {
+        self.code
+    }
+}
+impl Display for RunconError {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        write_full_error(f, &self.inner)
     }
-    desc.push('.');
-    desc
 }
diff --git a/src/uu/runcon/src/main.rs b/src/uu/runcon/src/main.rs
index 86aae54e5..1d3cef4cb 100644
--- a/src/uu/runcon/src/main.rs
+++ b/src/uu/runcon/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_runcon);
+uucore::bin!(uu_runcon);
diff --git a/src/uu/runcon/src/runcon.rs b/src/uu/runcon/src/runcon.rs
index b2f1468bd..8c20319be 100644
--- a/src/uu/runcon/src/runcon.rs
+++ b/src/uu/runcon/src/runcon.rs
@@ -1,9 +1,10 @@
 // spell-checker:ignore (vars) RFILE
 
-use uucore::{show_error, show_usage_error};
+use uucore::error::{UResult, UUsageError};
 
-use clap::{App, Arg};
+use clap::{Arg, Command};
 use selinux::{OpaqueSecurityContext, SecurityClass, SecurityContext};
+use uucore::format_usage;
 
 use std::borrow::Cow;
 use std::ffi::{CStr, CString, OsStr, OsString};
@@ -13,10 +14,14 @@ use std::{io, ptr};
 
 mod errors;
 
-use errors::{report_full_error, Error, Result};
+use errors::error_exit_status;
+use errors::{Error, Result, RunconError};
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 const ABOUT: &str = "Run command with specified security context.";
+const USAGE: &str = "\
+    {} [CONTEXT COMMAND [ARG...]]
+    {} [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]";
 const DESCRIPTION: &str = "Run COMMAND with completely-specified CONTEXT, or with current or \
                       transitioned security context modified by one or more of \
                       LEVEL, ROLE, TYPE, and USER.\n\n\
@@ -35,69 +40,39 @@ pub mod options {
     pub const RANGE: &str = "range";
 }
 
-// This list is NOT exhaustive. This command might perform an `execvp()` to run
-// a different program. When that happens successfully, the exit status of this
-// process will be the exit status of that program.
-mod error_exit_status {
-    pub const SUCCESS: i32 = libc::EXIT_SUCCESS;
-    pub const NOT_FOUND: i32 = 127;
-    pub const COULD_NOT_EXECUTE: i32 = 126;
-    pub const ANOTHER_ERROR: i32 = libc::EXIT_FAILURE;
-}
-
-fn get_usage() -> String {
-    format!(
-        "{0} [CONTEXT COMMAND [ARG...]]\n    \
-         {0} [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]",
-        uucore::execution_phrase()
-    )
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = get_usage();
-
-    let config = uu_app().usage(usage.as_ref());
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let config = uu_app();
 
     let options = match parse_command_line(config, args) {
         Ok(r) => r,
         Err(r) => {
             if let Error::CommandLine(ref r) = r {
-                match r.kind {
-                    clap::ErrorKind::HelpDisplayed | clap::ErrorKind::VersionDisplayed => {
+                match r.kind() {
+                    clap::ErrorKind::DisplayHelp | clap::ErrorKind::DisplayVersion => {
                         println!("{}", r);
-                        return error_exit_status::SUCCESS;
+                        return Ok(());
                     }
                     _ => {}
                 }
             }
-
-            show_usage_error!("{}.\n", r);
-            return error_exit_status::ANOTHER_ERROR;
+            return Err(UUsageError::new(
+                error_exit_status::ANOTHER_ERROR,
+                format!("{}", r),
+            ));
         }
     };
 
     match &options.mode {
-        CommandLineMode::Print => {
-            if let Err(r) = print_current_context() {
-                show_error!("{}", report_full_error(&r));
-                return error_exit_status::ANOTHER_ERROR;
-            }
-        }
-
+        CommandLineMode::Print => print_current_context().map_err(|e| RunconError::new(e).into()),
         CommandLineMode::PlainContext { context, command } => {
-            let (exit_status, err) =
-                if let Err(err) = get_plain_context(context).and_then(set_next_exec_context) {
-                    (error_exit_status::ANOTHER_ERROR, err)
-                } else {
-                    // On successful execution, the following call never returns,
-                    // and this process image is replaced.
-                    execute_command(command, &options.arguments)
-                };
-
-            show_error!("{}", report_full_error(&err));
-            return exit_status;
+            get_plain_context(context)
+                .and_then(|ctx| set_next_exec_context(&ctx))
+                .map_err(RunconError::new)?;
+            // On successful execution, the following call never returns,
+            // and this process image is replaced.
+            execute_command(command, &options.arguments)
         }
-
         CommandLineMode::CustomContext {
             compute_transition_context,
             user,
@@ -106,86 +81,88 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             range,
             command,
         } => {
-            if let Some(command) = command {
-                let (exit_status, err) = if let Err(err) = get_custom_context(
-                    *compute_transition_context,
-                    user.as_deref(),
-                    role.as_deref(),
-                    the_type.as_deref(),
-                    range.as_deref(),
-                    command,
-                )
-                .and_then(set_next_exec_context)
-                {
-                    (error_exit_status::ANOTHER_ERROR, err)
-                } else {
+            match command {
+                Some(command) => {
+                    get_custom_context(
+                        *compute_transition_context,
+                        user.as_deref(),
+                        role.as_deref(),
+                        the_type.as_deref(),
+                        range.as_deref(),
+                        command,
+                    )
+                    .and_then(|ctx| set_next_exec_context(&ctx))
+                    .map_err(RunconError::new)?;
                     // On successful execution, the following call never returns,
                     // and this process image is replaced.
                     execute_command(command, &options.arguments)
-                };
-
-                show_error!("{}", report_full_error(&err));
-                return exit_status;
-            } else if let Err(r) = print_current_context() {
-                show_error!("{}", report_full_error(&r));
-                return error_exit_status::ANOTHER_ERROR;
+                }
+                None => print_current_context().map_err(|e| RunconError::new(e).into()),
             }
         }
     }
-
-    error_exit_status::SUCCESS
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(VERSION)
         .about(ABOUT)
         .after_help(DESCRIPTION)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::COMPUTE)
-                .short("c")
+            Arg::new(options::COMPUTE)
+                .short('c')
                 .long(options::COMPUTE)
                 .takes_value(false)
                 .help("Compute process transition context before modifying."),
         )
         .arg(
-            Arg::with_name(options::USER)
-                .short("u")
+            Arg::new(options::USER)
+                .short('u')
                 .long(options::USER)
                 .takes_value(true)
                 .value_name("USER")
-                .help("Set user USER in the target security context."),
+                .help("Set user USER in the target security context.")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::ROLE)
-                .short("r")
+            Arg::new(options::ROLE)
+                .short('r')
                 .long(options::ROLE)
                 .takes_value(true)
                 .value_name("ROLE")
-                .help("Set role ROLE in the target security context."),
+                .help("Set role ROLE in the target security context.")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::TYPE)
-                .short("t")
+            Arg::new(options::TYPE)
+                .short('t')
                 .long(options::TYPE)
                 .takes_value(true)
                 .value_name("TYPE")
-                .help("Set type TYPE in the target security context."),
+                .help("Set type TYPE in the target security context.")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::RANGE)
-                .short("l")
+            Arg::new(options::RANGE)
+                .short('l')
                 .long(options::RANGE)
                 .takes_value(true)
                 .value_name("RANGE")
-                .help("Set range RANGE in the target security context."),
+                .help("Set range RANGE in the target security context.")
+                .allow_invalid_utf8(true),
+        )
+        .arg(
+            Arg::new("ARG")
+                .multiple_occurrences(true)
+                .allow_invalid_utf8(true),
         )
-        .arg(Arg::with_name("ARG").multiple(true))
         // Once "ARG" is parsed, everything after that belongs to it.
         //
         // This is not how POSIX does things, but this is how the GNU implementation
         // parses its command line.
-        .setting(clap::AppSettings::TrailingVarArg)
+        .trailing_var_arg(true)
 }
 
 #[derive(Debug)]
@@ -228,8 +205,8 @@ struct Options {
     arguments: Vec<OsString>,
 }
 
-fn parse_command_line(config: App, args: impl uucore::Args) -> Result<Options> {
-    let matches = config.get_matches_from_safe(args)?;
+fn parse_command_line(config: Command, args: impl uucore::Args) -> Result<Options> {
+    let matches = config.try_get_matches_from(args)?;
 
     let compute_transition_context = matches.is_present(options::COMPUTE);
 
@@ -295,7 +272,7 @@ fn print_current_context() -> Result<()> {
     Ok(())
 }
 
-fn set_next_exec_context(context: OpaqueSecurityContext) -> Result<()> {
+fn set_next_exec_context(context: &OpaqueSecurityContext) -> Result<()> {
     let c_context = context
         .to_c_string()
         .map_err(|r| Error::from_selinux("Creating new context", r))?;
@@ -406,25 +383,19 @@ fn get_custom_context(
     Ok(osc)
 }
 
-/// The actual return type of this function should be `Result<!, (i32, Error)>`
+/// The actual return type of this function should be `UResult<!>`.
 /// However, until the *never* type is stabilized, one way to indicate to the
 /// compiler the only valid return type is to say "if this returns, it will
 /// always return an error".
-fn execute_command(command: &OsStr, arguments: &[OsString]) -> (i32, Error) {
-    let c_command = match os_str_to_c_string(command) {
-        Ok(v) => v,
-        Err(r) => return (error_exit_status::ANOTHER_ERROR, r),
-    };
+fn execute_command(command: &OsStr, arguments: &[OsString]) -> UResult<()> {
+    let c_command = os_str_to_c_string(command).map_err(RunconError::new)?;
 
-    let argv_storage: Vec<CString> = match arguments
+    let argv_storage: Vec<CString> = arguments
         .iter()
         .map(AsRef::as_ref)
         .map(os_str_to_c_string)
         .collect::<Result<_>>()
-    {
-        Ok(v) => v,
-        Err(r) => return (error_exit_status::ANOTHER_ERROR, r),
-    };
+        .map_err(RunconError::new)?;
 
     let mut argv: Vec<*const c_char> = Vec::with_capacity(arguments.len().saturating_add(2));
     argv.push(c_command.as_ptr());
@@ -441,7 +412,7 @@ fn execute_command(command: &OsStr, arguments: &[OsString]) -> (i32, Error) {
     };
 
     let err = Error::from_io1("Executing command", command, err);
-    (exit_status, err)
+    Err(RunconError::with_code(exit_status, err).into())
 }
 
 fn os_str_to_c_string(s: &OsStr) -> Result<CString> {
diff --git a/src/uu/seq/BENCHMARKING.md b/src/uu/seq/BENCHMARKING.md
new file mode 100644
index 000000000..4d2f82afe
--- /dev/null
+++ b/src/uu/seq/BENCHMARKING.md
@@ -0,0 +1,19 @@
+# Benchmarking to measure performance
+
+To compare the performance of the `uutils` version of `seq` with the
+GNU version of `seq`, you can use a benchmarking tool like
+[hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
+running
+
+    sudo apt-get install hyperfine
+
+Next, build the `seq` binary under the release profile:
+
+    cargo build --release -p uu_seq
+
+Finally, you can compare the performance of the two versions of `head`
+by running, for example,
+
+    hyperfine "seq 1000000" "target/release/seq 1000000"
+
+[0]: https://github.com/sharkdp/hyperfine
diff --git a/src/uu/seq/Cargo.toml b/src/uu/seq/Cargo.toml
index f5a23310f..b6573a792 100644
--- a/src/uu/seq/Cargo.toml
+++ b/src/uu/seq/Cargo.toml
@@ -1,12 +1,13 @@
+# spell-checker:ignore bigdecimal
 [package]
 name = "uu_seq"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "seq ~ (uutils) display a sequence of numbers"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/seq"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/seq"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,16 +16,12 @@ edition = "2018"
 path = "src/seq.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+bigdecimal = "0.3"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 num-bigint = "0.4.0"
 num-traits = "0.2.14"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["memo"] }
 
 [[bin]]
 name = "seq"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/seq/LICENSE b/src/uu/seq/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/seq/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/seq/src/digits.rs b/src/uu/seq/src/digits.rs
deleted file mode 100644
index bde933978..000000000
--- a/src/uu/seq/src/digits.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-//! Counting number of digits needed to represent a number.
-//!
-//! The [`num_integral_digits`] and [`num_fractional_digits`] functions
-//! count the number of digits needed to represent a number in decimal
-//! notation (like "123.456").
-use std::convert::TryInto;
-use std::num::ParseIntError;
-
-use uucore::display::Quotable;
-
-/// The number of digits after the decimal point in a given number.
-///
-/// The input `s` is a string representing a number, either an integer
-/// or a floating point number in either decimal notation or scientific
-/// notation. This function returns the number of digits after the
-/// decimal point needed to print the number in decimal notation.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// assert_eq!(num_fractional_digits("123.45e-1").unwrap(), 3);
-/// ```
-pub fn num_fractional_digits(s: &str) -> Result<usize, ParseIntError> {
-    match (s.find('.'), s.find('e')) {
-        // For example, "123456".
-        (None, None) => Ok(0),
-
-        // For example, "123e456".
-        (None, Some(j)) => {
-            let exponent: i64 = s[j + 1..].parse()?;
-            if exponent < 0 {
-                Ok(-exponent as usize)
-            } else {
-                Ok(0)
-            }
-        }
-
-        // For example, "123.456".
-        (Some(i), None) => Ok(s.len() - (i + 1)),
-
-        // For example, "123.456e789".
-        (Some(i), Some(j)) if i < j => {
-            // Because of the match guard, this subtraction will not underflow.
-            let num_digits_between_decimal_point_and_e = (j - (i + 1)) as i64;
-            let exponent: i64 = s[j + 1..].parse()?;
-            if num_digits_between_decimal_point_and_e < exponent {
-                Ok(0)
-            } else {
-                Ok((num_digits_between_decimal_point_and_e - exponent)
-                    .try_into()
-                    .unwrap())
-            }
-        }
-        _ => crash!(
-            1,
-            "invalid floating point argument: {}\n Try '{} --help' for more information.",
-            s.quote(),
-            uucore::execution_phrase()
-        ),
-    }
-}
-
-/// The number of digits before the decimal point in a given number.
-///
-/// The input `s` is a string representing a number, either an integer
-/// or a floating point number in either decimal notation or scientific
-/// notation. This function returns the number of digits before the
-/// decimal point needed to print the number in decimal notation.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// assert_eq!(num_fractional_digits("123.45e-1").unwrap(), 2);
-/// ```
-pub fn num_integral_digits(s: &str) -> Result<usize, ParseIntError> {
-    match (s.find('.'), s.find('e')) {
-        // For example, "123456".
-        (None, None) => Ok(s.len()),
-
-        // For example, "123e456".
-        (None, Some(j)) => {
-            let exponent: i64 = s[j + 1..].parse()?;
-            let total = j as i64 + exponent;
-            if total < 1 {
-                Ok(1)
-            } else {
-                Ok(total.try_into().unwrap())
-            }
-        }
-
-        // For example, "123.456".
-        (Some(i), None) => Ok(i),
-
-        // For example, "123.456e789".
-        (Some(i), Some(j)) => {
-            let exponent: i64 = s[j + 1..].parse()?;
-            let minimum: usize = {
-                let integral_part: f64 = crash_if_err!(1, s[..j].parse());
-                if integral_part == -0.0 && integral_part.is_sign_negative() {
-                    2
-                } else {
-                    1
-                }
-            };
-
-            let total = i as i64 + exponent;
-            if total < minimum as i64 {
-                Ok(minimum)
-            } else {
-                Ok(total.try_into().unwrap())
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    mod test_num_integral_digits {
-        use crate::num_integral_digits;
-
-        #[test]
-        fn test_integer() {
-            assert_eq!(num_integral_digits("123").unwrap(), 3);
-        }
-
-        #[test]
-        fn test_decimal() {
-            assert_eq!(num_integral_digits("123.45").unwrap(), 3);
-        }
-
-        #[test]
-        fn test_scientific_no_decimal_positive_exponent() {
-            assert_eq!(num_integral_digits("123e4").unwrap(), 3 + 4);
-        }
-
-        #[test]
-        fn test_scientific_with_decimal_positive_exponent() {
-            assert_eq!(num_integral_digits("123.45e6").unwrap(), 3 + 6);
-        }
-
-        #[test]
-        fn test_scientific_no_decimal_negative_exponent() {
-            assert_eq!(num_integral_digits("123e-4").unwrap(), 1);
-        }
-
-        #[test]
-        fn test_scientific_with_decimal_negative_exponent() {
-            assert_eq!(num_integral_digits("123.45e-6").unwrap(), 1);
-            assert_eq!(num_integral_digits("123.45e-1").unwrap(), 2);
-        }
-    }
-
-    mod test_num_fractional_digits {
-        use crate::num_fractional_digits;
-
-        #[test]
-        fn test_integer() {
-            assert_eq!(num_fractional_digits("123").unwrap(), 0);
-        }
-
-        #[test]
-        fn test_decimal() {
-            assert_eq!(num_fractional_digits("123.45").unwrap(), 2);
-        }
-
-        #[test]
-        fn test_scientific_no_decimal_positive_exponent() {
-            assert_eq!(num_fractional_digits("123e4").unwrap(), 0);
-        }
-
-        #[test]
-        fn test_scientific_with_decimal_positive_exponent() {
-            assert_eq!(num_fractional_digits("123.45e6").unwrap(), 0);
-            assert_eq!(num_fractional_digits("123.45e1").unwrap(), 1);
-        }
-
-        #[test]
-        fn test_scientific_no_decimal_negative_exponent() {
-            assert_eq!(num_fractional_digits("123e-4").unwrap(), 4);
-            assert_eq!(num_fractional_digits("123e-1").unwrap(), 1);
-        }
-
-        #[test]
-        fn test_scientific_with_decimal_negative_exponent() {
-            assert_eq!(num_fractional_digits("123.45e-6").unwrap(), 8);
-            assert_eq!(num_fractional_digits("123.45e-1").unwrap(), 3);
-        }
-    }
-}
diff --git a/src/uu/seq/src/error.rs b/src/uu/seq/src/error.rs
new file mode 100644
index 000000000..8c372758c
--- /dev/null
+++ b/src/uu/seq/src/error.rs
@@ -0,0 +1,70 @@
+//  * 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 numberparse argtype
+//! Errors returned by seq.
+use std::error::Error;
+use std::fmt::Display;
+
+use uucore::display::Quotable;
+use uucore::error::UError;
+
+use crate::numberparse::ParseNumberError;
+
+#[derive(Debug)]
+pub enum SeqError {
+    /// An error parsing the input arguments.
+    ///
+    /// The parameters are the [`String`] argument as read from the
+    /// command line and the underlying parsing error itself.
+    ParseError(String, ParseNumberError),
+
+    /// The increment argument was zero, which is not allowed.
+    ///
+    /// The parameter is the increment argument as a [`String`] as read
+    /// from the command line.
+    ZeroIncrement(String),
+}
+
+impl SeqError {
+    /// The [`String`] argument as read from the command-line.
+    fn arg(&self) -> &str {
+        match self {
+            SeqError::ParseError(s, _) => s,
+            SeqError::ZeroIncrement(s) => s,
+        }
+    }
+
+    /// The type of argument that is causing the error.
+    fn argtype(&self) -> &str {
+        match self {
+            SeqError::ParseError(_, e) => match e {
+                ParseNumberError::Float => "floating point argument",
+                ParseNumberError::Nan => "'not-a-number' argument",
+                ParseNumberError::Hex => "hexadecimal argument",
+            },
+            SeqError::ZeroIncrement(_) => "Zero increment value",
+        }
+    }
+}
+impl UError for SeqError {
+    /// Always return 1.
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+impl Error for SeqError {}
+
+impl Display for SeqError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "invalid {}: {}\nTry '{} --help' for more information.",
+            self.argtype(),
+            self.arg().quote(),
+            uucore::execution_phrase(),
+        )
+    }
+}
diff --git a/src/uu/seq/src/extendedbigdecimal.rs b/src/uu/seq/src/extendedbigdecimal.rs
new file mode 100644
index 000000000..253fadfd5
--- /dev/null
+++ b/src/uu/seq/src/extendedbigdecimal.rs
@@ -0,0 +1,278 @@
+// spell-checker:ignore bigdecimal extendedbigdecimal extendedbigint
+//! An arbitrary precision float that can also represent infinity, NaN, etc.
+//!
+//! The finite values are stored as [`BigDecimal`] instances. Because
+//! the `bigdecimal` library does not represent infinity, NaN, etc., we
+//! need to represent them explicitly ourselves. The
+//! [`ExtendedBigDecimal`] enumeration does that.
+//!
+//! # Examples
+//!
+//! Addition works for [`ExtendedBigDecimal`] as it does for floats. For
+//! example, adding infinity to any finite value results in infinity:
+//!
+//! ```rust,ignore
+//! let summand1 = ExtendedBigDecimal::BigDecimal(BigDecimal::zero());
+//! let summand2 = ExtendedBigDecimal::Infinity;
+//! assert_eq!(summand1 + summand2, ExtendedBigDecimal::Infinity);
+//! ```
+use std::cmp::Ordering;
+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.
+    BigDecimal(BigDecimal),
+
+    /// Floating point positive infinity.
+    ///
+    /// This is represented as its own enumeration member instead of as
+    /// a [`BigDecimal`] because the `bigdecimal` library does not
+    /// support infinity, see [here][0].
+    ///
+    /// [0]: https://github.com/akubera/bigdecimal-rs/issues/67
+    Infinity,
+
+    /// Floating point negative infinity.
+    ///
+    /// This is represented as its own enumeration member instead of as
+    /// a [`BigDecimal`] because the `bigdecimal` library does not
+    /// support infinity, see [here][0].
+    ///
+    /// [0]: https://github.com/akubera/bigdecimal-rs/issues/67
+    MinusInfinity,
+
+    /// Floating point negative zero.
+    ///
+    /// This is represented as its own enumeration member instead of as
+    /// a [`BigDecimal`] because the `bigdecimal` library does not
+    /// support negative zero.
+    MinusZero,
+
+    /// Floating point NaN.
+    ///
+    /// This is represented as its own enumeration member instead of as
+    /// a [`BigDecimal`] because the `bigdecimal` library does not
+    /// support NaN, see [here][0].
+    ///
+    /// [0]: https://github.com/akubera/bigdecimal-rs/issues/67
+    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),
+        }
+    }
+
+    /// 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,
+        }
+    }
+}
+
+impl Display for ExtendedBigDecimal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::BigDecimal(x) => {
+                let (n, p) = x.as_bigint_and_exponent();
+                match p {
+                    0 => Self::BigDecimal(BigDecimal::new(n * 10, 1)).fmt(f),
+                    _ => x.fmt(f),
+                }
+            }
+            Self::Infinity => f32::INFINITY.fmt(f),
+            Self::MinusInfinity => f32::NEG_INFINITY.fmt(f),
+            Self::MinusZero => (-0.0f32).fmt(f),
+            Self::Nan => "nan".fmt(f),
+        }
+    }
+}
+
+impl Zero for ExtendedBigDecimal {
+    fn zero() -> Self {
+        Self::BigDecimal(BigDecimal::zero())
+    }
+    fn is_zero(&self) -> bool {
+        match self {
+            Self::BigDecimal(n) => n.is_zero(),
+            Self::MinusZero => true,
+            _ => false,
+        }
+    }
+}
+
+impl Add for ExtendedBigDecimal {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        match (self, other) {
+            (Self::BigDecimal(m), Self::BigDecimal(n)) => Self::BigDecimal(m.add(n)),
+            (Self::BigDecimal(_), Self::MinusInfinity) => Self::MinusInfinity,
+            (Self::BigDecimal(_), Self::Infinity) => Self::Infinity,
+            (Self::BigDecimal(_), Self::Nan) => Self::Nan,
+            (Self::BigDecimal(m), Self::MinusZero) => Self::BigDecimal(m),
+            (Self::Infinity, Self::BigDecimal(_)) => 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::BigDecimal(_)) => 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 ExtendedBigDecimal {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::BigDecimal(m), Self::BigDecimal(n)) => m.eq(n),
+            (Self::BigDecimal(_), Self::MinusInfinity) => false,
+            (Self::BigDecimal(_), Self::Infinity) => false,
+            (Self::BigDecimal(_), Self::Nan) => false,
+            (Self::BigDecimal(_), Self::MinusZero) => false,
+            (Self::Infinity, Self::BigDecimal(_)) => false,
+            (Self::Infinity, Self::Infinity) => true,
+            (Self::Infinity, Self::MinusZero) => false,
+            (Self::Infinity, Self::MinusInfinity) => false,
+            (Self::Infinity, Self::Nan) => false,
+            (Self::MinusInfinity, Self::BigDecimal(_)) => 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::BigDecimal(_)) => false,
+            (Self::MinusZero, Self::Infinity) => false,
+            (Self::MinusZero, Self::MinusZero) => true,
+            (Self::MinusZero, Self::MinusInfinity) => false,
+            (Self::MinusZero, Self::Nan) => false,
+        }
+    }
+}
+
+impl PartialOrd for ExtendedBigDecimal {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            (Self::BigDecimal(m), Self::BigDecimal(n)) => m.partial_cmp(n),
+            (Self::BigDecimal(_), Self::MinusInfinity) => Some(Ordering::Greater),
+            (Self::BigDecimal(_), Self::Infinity) => Some(Ordering::Less),
+            (Self::BigDecimal(_), Self::Nan) => None,
+            (Self::BigDecimal(m), Self::MinusZero) => m.partial_cmp(&BigDecimal::zero()),
+            (Self::Infinity, Self::BigDecimal(_)) => 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::BigDecimal(_)) => 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::BigDecimal(n)) => BigDecimal::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 bigdecimal::BigDecimal;
+    use num_traits::Zero;
+
+    use crate::extendedbigdecimal::ExtendedBigDecimal;
+
+    #[test]
+    fn test_addition_infinity() {
+        let summand1 = ExtendedBigDecimal::BigDecimal(BigDecimal::zero());
+        let summand2 = ExtendedBigDecimal::Infinity;
+        assert_eq!(summand1 + summand2, ExtendedBigDecimal::Infinity);
+    }
+
+    #[test]
+    fn test_addition_minus_infinity() {
+        let summand1 = ExtendedBigDecimal::BigDecimal(BigDecimal::zero());
+        let summand2 = ExtendedBigDecimal::MinusInfinity;
+        assert_eq!(summand1 + summand2, ExtendedBigDecimal::MinusInfinity);
+    }
+
+    #[test]
+    fn test_addition_nan() {
+        let summand1 = ExtendedBigDecimal::BigDecimal(BigDecimal::zero());
+        let summand2 = ExtendedBigDecimal::Nan;
+        let sum = summand1 + summand2;
+        match sum {
+            ExtendedBigDecimal::Nan => (),
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_display() {
+        assert_eq!(
+            format!("{}", ExtendedBigDecimal::BigDecimal(BigDecimal::zero())),
+            "0.0"
+        );
+        assert_eq!(format!("{}", ExtendedBigDecimal::Infinity), "inf");
+        assert_eq!(format!("{}", ExtendedBigDecimal::MinusInfinity), "-inf");
+        assert_eq!(format!("{}", ExtendedBigDecimal::Nan), "nan");
+        assert_eq!(format!("{}", ExtendedBigDecimal::MinusZero), "-0");
+    }
+}
diff --git a/src/uu/seq/src/extendedbigint.rs b/src/uu/seq/src/extendedbigint.rs
new file mode 100644
index 000000000..bbe64300a
--- /dev/null
+++ b/src/uu/seq/src/extendedbigint.rs
@@ -0,0 +1,218 @@
+// 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 => {
+                // FIXME Come up with a way of formatting this with a
+                // "-" prefix.
+                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::Infinity), "inf");
+        assert_eq!(format!("{}", ExtendedBigInt::MinusInfinity), "-inf");
+        assert_eq!(format!("{}", ExtendedBigInt::Nan), "nan");
+        // FIXME Come up with a way of displaying negative zero as
+        // "-0". Currently it displays as just "0".
+        //
+        //     assert_eq!(format!("{}", ExtendedBigInt::MinusZero), "-0");
+        //
+    }
+}
diff --git a/src/uu/seq/src/main.rs b/src/uu/seq/src/main.rs
index 266ac5d11..4b8a296b9 100644
--- a/src/uu/seq/src/main.rs
+++ b/src/uu/seq/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_seq);
+uucore::bin!(uu_seq);
diff --git a/src/uu/seq/src/number.rs b/src/uu/seq/src/number.rs
new file mode 100644
index 000000000..1b46f8f55
--- /dev/null
+++ b/src/uu/seq/src/number.rs
@@ -0,0 +1,115 @@
+// 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`].
+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 {
+            Number::Int(n) => n.is_zero(),
+            Number::Float(x) => x.is_zero(),
+        }
+    }
+
+    /// Convert this number into an `ExtendedBigDecimal`.
+    pub fn into_extended_big_decimal(self) -> ExtendedBigDecimal {
+        match self {
+            Number::Int(n) => ExtendedBigDecimal::from(n),
+            Number::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`.
+            Number::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.
+            Number::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.
+///
+/// This struct can be used to represent a number along with information
+/// on how many significant digits to use when displaying the number.
+/// The [`PreciseNumber::num_integral_digits`] field also includes the width needed to
+/// display the "-" character for a negative number.
+///
+/// You can get an instance of this struct by calling [`str::parse`].
+#[derive(Debug)]
+pub struct PreciseNumber {
+    pub number: Number,
+    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 {
+        Self {
+            number,
+            num_integral_digits,
+            num_fractional_digits,
+        }
+    }
+
+    /// 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::new(Number::one(), 1, 0)
+    }
+
+    /// 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.
+        self.number.is_zero()
+    }
+}
diff --git a/src/uu/seq/src/numberparse.rs b/src/uu/seq/src/numberparse.rs
new file mode 100644
index 000000000..06f553478
--- /dev/null
+++ b/src/uu/seq/src/numberparse.rs
@@ -0,0 +1,618 @@
+// spell-checker:ignore extendedbigdecimal extendedbigint bigdecimal numberparse
+//! Parsing numbers for use in `seq`.
+//!
+//! This module provides an implementation of [`FromStr`] for the
+//! [`PreciseNumber`] struct.
+use std::convert::TryInto;
+use std::str::FromStr;
+
+use bigdecimal::BigDecimal;
+use num_bigint::BigInt;
+use num_bigint::Sign;
+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.
+#[derive(Debug, PartialEq)]
+pub enum ParseNumberError {
+    Float,
+    Nan,
+    Hex,
+}
+
+/// 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()
+}
+
+/// Decide whether a given string and its parsed `BigDecimal` is negative zero.
+fn is_minus_zero_float(s: &str, x: &BigDecimal) -> bool {
+    s.starts_with('-') && x == &BigDecimal::zero()
+}
+
+/// Parse a number with neither a decimal point nor an exponent.
+///
+/// # Errors
+///
+/// This function returns an error if the input string is a variant of
+/// "NaN" or if no [`BigInt`] could be parsed from the string.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// let actual = "0".parse::<Number>().unwrap().number;
+/// let expected = Number::BigInt(BigInt::zero());
+/// assert_eq!(actual, expected);
+/// ```
+fn parse_no_decimal_no_exponent(s: &str) -> Result<PreciseNumber, ParseNumberError> {
+    match s.parse::<BigInt>() {
+        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),
+                    s.len(),
+                    0,
+                ))
+            } else {
+                Ok(PreciseNumber::new(
+                    Number::Int(ExtendedBigInt::BigInt(n)),
+                    s.len(),
+                    0,
+                ))
+            }
+        }
+        Err(_) => {
+            // Possibly "NaN" or "inf".
+            //
+            // TODO In Rust v1.53.0, this change
+            // https://github.com/rust-lang/rust/pull/78618 improves the
+            // parsing of floats to include being able to parse "NaN"
+            // and "inf". So when the minimum version of this crate is
+            // increased to 1.53.0, we should just use the built-in
+            // `f32` parsing instead.
+            if s.eq_ignore_ascii_case("inf") {
+                Ok(PreciseNumber::new(
+                    Number::Float(ExtendedBigDecimal::Infinity),
+                    0,
+                    0,
+                ))
+            } else if s.eq_ignore_ascii_case("-inf") {
+                Ok(PreciseNumber::new(
+                    Number::Float(ExtendedBigDecimal::MinusInfinity),
+                    0,
+                    0,
+                ))
+            } else if s.eq_ignore_ascii_case("nan") || s.eq_ignore_ascii_case("-nan") {
+                Err(ParseNumberError::Nan)
+            } else {
+                Err(ParseNumberError::Float)
+            }
+        }
+    }
+}
+
+/// Parse a number with an exponent but no decimal point.
+///
+/// # Errors
+///
+/// This function returns an error if `s` is not a valid number.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// let actual = "1e2".parse::<Number>().unwrap().number;
+/// let expected = "100".parse::<BigInt>().unwrap();
+/// assert_eq!(actual, expected);
+/// ```
+fn parse_exponent_no_decimal(s: &str, j: usize) -> Result<PreciseNumber, ParseNumberError> {
+    let exponent: i64 = s[j + 1..].parse().map_err(|_| ParseNumberError::Float)?;
+    // If the exponent is strictly less than zero, then the number
+    // should be treated as a floating point number that will be
+    // displayed in decimal notation. For example, "1e-2" will be
+    // displayed as "0.01", but "1e2" will be displayed as "100",
+    // without a decimal point.
+    let x: BigDecimal = s.parse().map_err(|_| ParseNumberError::Float)?;
+    let num_integral_digits = if is_minus_zero_float(s, &x) {
+        2
+    } else {
+        let total = j as i64 + exponent;
+        let result = if total < 1 {
+            1
+        } else {
+            total.try_into().unwrap()
+        };
+        if x.sign() == Sign::Minus {
+            result + 1
+        } else {
+            result
+        }
+    };
+    let num_fractional_digits = if exponent < 0 { -exponent as usize } else { 0 };
+
+    if exponent < 0 {
+        if is_minus_zero_float(s, &x) {
+            Ok(PreciseNumber::new(
+                Number::Float(ExtendedBigDecimal::MinusZero),
+                num_integral_digits,
+                num_fractional_digits,
+            ))
+        } else {
+            Ok(PreciseNumber::new(
+                Number::Float(ExtendedBigDecimal::BigDecimal(x)),
+                num_integral_digits,
+                num_fractional_digits,
+            ))
+        }
+    } else {
+        let zeros = "0".repeat(exponent.try_into().unwrap());
+        let expanded = [&s[0..j], &zeros].concat();
+        parse_no_decimal_no_exponent(&expanded)
+    }
+}
+
+/// Parse a number with a decimal point but no exponent.
+///
+/// # Errors
+///
+/// This function returns an error if `s` is not a valid number.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// let actual = "1.2".parse::<Number>().unwrap().number;
+/// let expected = "1.2".parse::<BigDecimal>().unwrap();
+/// assert_eq!(actual, expected);
+/// ```
+fn parse_decimal_no_exponent(s: &str, i: usize) -> Result<PreciseNumber, ParseNumberError> {
+    let x: BigDecimal = s.parse().map_err(|_| ParseNumberError::Float)?;
+
+    // The number of integral digits is the number of chars until the period.
+    //
+    // This includes the negative sign if there is one. Also, it is
+    // possible that a number is expressed as "-.123" instead of
+    // "-0.123", but when we display the number we want it to include
+    // the leading 0.
+    let num_integral_digits = if s.starts_with("-.") { i + 1 } else { i };
+    let num_fractional_digits = s.len() - (i + 1);
+    if is_minus_zero_float(s, &x) {
+        Ok(PreciseNumber::new(
+            Number::Float(ExtendedBigDecimal::MinusZero),
+            num_integral_digits,
+            num_fractional_digits,
+        ))
+    } else {
+        Ok(PreciseNumber::new(
+            Number::Float(ExtendedBigDecimal::BigDecimal(x)),
+            num_integral_digits,
+            num_fractional_digits,
+        ))
+    }
+}
+
+/// Parse a number with both a decimal point and an exponent.
+///
+/// # Errors
+///
+/// This function returns an error if `s` is not a valid number.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// let actual = "1.2e3".parse::<Number>().unwrap().number;
+/// let expected = "1200".parse::<BigInt>().unwrap();
+/// assert_eq!(actual, expected);
+/// ```
+fn parse_decimal_and_exponent(
+    s: &str,
+    i: usize,
+    j: usize,
+) -> Result<PreciseNumber, ParseNumberError> {
+    // Because of the match guard, this subtraction will not underflow.
+    let num_digits_between_decimal_point_and_e = (j - (i + 1)) as i64;
+    let exponent: i64 = s[j + 1..].parse().map_err(|_| ParseNumberError::Float)?;
+    let val: BigDecimal = s.parse().map_err(|_| ParseNumberError::Float)?;
+
+    let num_integral_digits = {
+        let minimum: usize = {
+            let integral_part: f64 = s[..j].parse().map_err(|_| ParseNumberError::Float)?;
+            if integral_part.is_sign_negative() {
+                2
+            } else {
+                1
+            }
+        };
+        // Special case: if the string is "-.1e2", we need to treat it
+        // as if it were "-0.1e2".
+        let total = if s.starts_with("-.") {
+            i as i64 + exponent + 1
+        } else {
+            i as i64 + exponent
+        };
+        if total < minimum as i64 {
+            minimum
+        } else {
+            total.try_into().unwrap()
+        }
+    };
+
+    let num_fractional_digits = if num_digits_between_decimal_point_and_e < exponent {
+        0
+    } else {
+        (num_digits_between_decimal_point_and_e - exponent)
+            .try_into()
+            .unwrap()
+    };
+
+    if num_digits_between_decimal_point_and_e <= exponent {
+        if is_minus_zero_float(s, &val) {
+            Ok(PreciseNumber::new(
+                Number::Int(ExtendedBigInt::MinusZero),
+                num_integral_digits,
+                num_fractional_digits,
+            ))
+        } else {
+            let zeros: String = "0".repeat(
+                (exponent - num_digits_between_decimal_point_and_e)
+                    .try_into()
+                    .unwrap(),
+            );
+            let expanded = [&s[0..i], &s[i + 1..j], &zeros].concat();
+            let n = expanded
+                .parse::<BigInt>()
+                .map_err(|_| ParseNumberError::Float)?;
+            Ok(PreciseNumber::new(
+                Number::Int(ExtendedBigInt::BigInt(n)),
+                num_integral_digits,
+                num_fractional_digits,
+            ))
+        }
+    } else if is_minus_zero_float(s, &val) {
+        Ok(PreciseNumber::new(
+            Number::Float(ExtendedBigDecimal::MinusZero),
+            num_integral_digits,
+            num_fractional_digits,
+        ))
+    } else {
+        Ok(PreciseNumber::new(
+            Number::Float(ExtendedBigDecimal::BigDecimal(val)),
+            num_integral_digits,
+            num_fractional_digits,
+        ))
+    }
+}
+
+/// Parse a hexadecimal integer from a string.
+///
+/// # Errors
+///
+/// This function returns an error if no [`BigInt`] could be parsed from
+/// the string.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// let actual = "0x0".parse::<Number>().unwrap().number;
+/// let expected = Number::BigInt(BigInt::zero());
+/// assert_eq!(actual, expected);
+/// ```
+fn parse_hexadecimal(s: &str) -> Result<PreciseNumber, ParseNumberError> {
+    let (is_neg, s) = if s.starts_with('-') {
+        (true, &s[3..])
+    } else {
+        (false, &s[2..])
+    };
+
+    if s.starts_with('-') || s.starts_with('+') {
+        // Even though this is more like an invalid hexadecimal number,
+        // GNU reports this as an invalid floating point number, so we
+        // use `ParseNumberError::Float` to match that behavior.
+        return Err(ParseNumberError::Float);
+    }
+
+    let num = BigInt::from_str_radix(s, 16).map_err(|_| ParseNumberError::Hex)?;
+
+    match (is_neg, num == BigInt::zero()) {
+        (true, true) => Ok(PreciseNumber::new(
+            Number::Int(ExtendedBigInt::MinusZero),
+            2,
+            0,
+        )),
+        (true, false) => Ok(PreciseNumber::new(
+            Number::Int(ExtendedBigInt::BigInt(-num)),
+            0,
+            0,
+        )),
+        (false, _) => Ok(PreciseNumber::new(
+            Number::Int(ExtendedBigInt::BigInt(num)),
+            0,
+            0,
+        )),
+    }
+}
+
+impl FromStr for PreciseNumber {
+    type Err = ParseNumberError;
+    fn from_str(mut s: &str) -> Result<Self, Self::Err> {
+        // Trim leading whitespace.
+        s = s.trim_start();
+
+        // Trim a single leading "+" character.
+        if s.starts_with('+') {
+            s = &s[1..];
+        }
+
+        // Check if the string seems to be in hexadecimal format.
+        //
+        // May be 0x123 or -0x123, so the index `i` may be either 0 or 1.
+        if let Some(i) = s.to_lowercase().find("0x") {
+            if i <= 1 {
+                return parse_hexadecimal(s);
+            }
+        }
+
+        // Find the decimal point and the exponent symbol. Parse the
+        // number differently depending on its form. This is important
+        // because the form of the input dictates how the output will be
+        // presented.
+        match (s.find('.'), s.find('e')) {
+            // For example, "123456" or "inf".
+            (None, None) => parse_no_decimal_no_exponent(s),
+            // For example, "123e456" or "1e-2".
+            (None, Some(j)) => parse_exponent_no_decimal(s, j),
+            // For example, "123.456".
+            (Some(i), None) => parse_decimal_no_exponent(s, i),
+            // For example, "123.456e789".
+            (Some(i), Some(j)) if i < j => parse_decimal_and_exponent(s, i, j),
+            // For example, "1e2.3" or "1.2.3".
+            _ => Err(ParseNumberError::Float),
+        }
+    }
+}
+
+#[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 {
+        s.parse::<PreciseNumber>().unwrap().number
+    }
+
+    /// Convenience function for getting the number of integral digits.
+    fn num_integral_digits(s: &str) -> usize {
+        s.parse::<PreciseNumber>().unwrap().num_integral_digits
+    }
+
+    /// Convenience function for getting the number of fractional digits.
+    fn num_fractional_digits(s: &str) -> usize {
+        s.parse::<PreciseNumber>().unwrap().num_fractional_digits
+    }
+
+    #[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));
+    }
+
+    #[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)
+        );
+    }
+
+    #[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("1.0e1"),
+            Number::Int(ExtendedBigInt::BigInt("10".parse::<BigInt>().unwrap()))
+        );
+    }
+
+    #[test]
+    fn test_parse_hexadecimal_big_int() {
+        assert_eq!(parse("0x0"), Number::Int(ExtendedBigInt::zero()));
+        assert_eq!(
+            parse("0x10"),
+            Number::Int(ExtendedBigInt::BigInt("16".parse::<BigInt>().unwrap()))
+        );
+    }
+
+    #[test]
+    fn test_parse_big_decimal() {
+        assert_eq!(
+            parse("0.0"),
+            Number::Float(ExtendedBigDecimal::BigDecimal(
+                "0.0".parse::<BigDecimal>().unwrap()
+            ))
+        );
+        assert_eq!(
+            parse(".0"),
+            Number::Float(ExtendedBigDecimal::BigDecimal(
+                "0.0".parse::<BigDecimal>().unwrap()
+            ))
+        );
+        assert_eq!(
+            parse("1.0"),
+            Number::Float(ExtendedBigDecimal::BigDecimal(
+                "1.0".parse::<BigDecimal>().unwrap()
+            ))
+        );
+        assert_eq!(
+            parse("10e-1"),
+            Number::Float(ExtendedBigDecimal::BigDecimal(
+                "1.0".parse::<BigDecimal>().unwrap()
+            ))
+        );
+        assert_eq!(
+            parse("-1e-3"),
+            Number::Float(ExtendedBigDecimal::BigDecimal(
+                "-0.001".parse::<BigDecimal>().unwrap()
+            ))
+        );
+    }
+
+    #[test]
+    fn test_parse_inf() {
+        assert_eq!(parse("inf"), Number::Float(ExtendedBigDecimal::Infinity));
+        assert_eq!(parse("+inf"), Number::Float(ExtendedBigDecimal::Infinity));
+        assert_eq!(
+            parse("-inf"),
+            Number::Float(ExtendedBigDecimal::MinusInfinity)
+        );
+    }
+
+    #[test]
+    fn test_parse_invalid_float() {
+        assert_eq!(
+            "1.2.3".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Float
+        );
+        assert_eq!(
+            "1e2e3".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Float
+        );
+        assert_eq!(
+            "1e2.3".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Float
+        );
+        assert_eq!(
+            "-+-1".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Float
+        );
+    }
+
+    #[test]
+    fn test_parse_invalid_hex() {
+        assert_eq!(
+            "0xg".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Hex
+        );
+    }
+
+    #[test]
+    fn test_parse_invalid_nan() {
+        assert_eq!(
+            "nan".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Nan
+        );
+        assert_eq!(
+            "NAN".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Nan
+        );
+        assert_eq!(
+            "NaN".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Nan
+        );
+        assert_eq!(
+            "nAn".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Nan
+        );
+        assert_eq!(
+            "-nan".parse::<PreciseNumber>().unwrap_err(),
+            ParseNumberError::Nan
+        );
+    }
+
+    #[test]
+    fn test_num_integral_digits() {
+        // no decimal, no exponent
+        assert_eq!(num_integral_digits("123"), 3);
+        // decimal, no exponent
+        assert_eq!(num_integral_digits("123.45"), 3);
+        assert_eq!(num_integral_digits("-0.1"), 2);
+        assert_eq!(num_integral_digits("-.1"), 2);
+        // exponent, no decimal
+        assert_eq!(num_integral_digits("123e4"), 3 + 4);
+        assert_eq!(num_integral_digits("123e-4"), 1);
+        assert_eq!(num_integral_digits("-1e-3"), 2);
+        // decimal and exponent
+        assert_eq!(num_integral_digits("123.45e6"), 3 + 6);
+        assert_eq!(num_integral_digits("123.45e-6"), 1);
+        assert_eq!(num_integral_digits("123.45e-1"), 2);
+        assert_eq!(num_integral_digits("-0.1e0"), 2);
+        assert_eq!(num_integral_digits("-0.1e2"), 4);
+        assert_eq!(num_integral_digits("-.1e0"), 2);
+        assert_eq!(num_integral_digits("-.1e2"), 4);
+        assert_eq!(num_integral_digits("-1.e-3"), 2);
+        assert_eq!(num_integral_digits("-1.0e-4"), 2);
+        // minus zero int
+        assert_eq!(num_integral_digits("-0e0"), 2);
+        assert_eq!(num_integral_digits("-0e-0"), 2);
+        assert_eq!(num_integral_digits("-0e1"), 3);
+        assert_eq!(num_integral_digits("-0e+1"), 3);
+        assert_eq!(num_integral_digits("-0.0e1"), 3);
+        // minus zero float
+        assert_eq!(num_integral_digits("-0.0"), 2);
+        assert_eq!(num_integral_digits("-0e-1"), 2);
+        assert_eq!(num_integral_digits("-0.0e-1"), 2);
+
+        // TODO In GNU `seq`, the `-w` option does not seem to work with
+        // hexadecimal arguments. In order to match that behavior, we
+        // report the number of integral digits as zero for hexadecimal
+        // inputs.
+        assert_eq!(num_integral_digits("0xff"), 0);
+    }
+
+    #[test]
+    fn test_num_fractional_digits() {
+        // no decimal, no exponent
+        assert_eq!(num_fractional_digits("123"), 0);
+        assert_eq!(num_fractional_digits("0xff"), 0);
+        // decimal, no exponent
+        assert_eq!(num_fractional_digits("123.45"), 2);
+        assert_eq!(num_fractional_digits("-0.1"), 1);
+        assert_eq!(num_fractional_digits("-.1"), 1);
+        // exponent, no decimal
+        assert_eq!(num_fractional_digits("123e4"), 0);
+        assert_eq!(num_fractional_digits("123e-4"), 4);
+        assert_eq!(num_fractional_digits("123e-1"), 1);
+        assert_eq!(num_fractional_digits("-1e-3"), 3);
+        // decimal and exponent
+        assert_eq!(num_fractional_digits("123.45e6"), 0);
+        assert_eq!(num_fractional_digits("123.45e1"), 1);
+        assert_eq!(num_fractional_digits("123.45e-6"), 8);
+        assert_eq!(num_fractional_digits("123.45e-1"), 3);
+        assert_eq!(num_fractional_digits("-0.1e0"), 1);
+        assert_eq!(num_fractional_digits("-0.1e2"), 0);
+        assert_eq!(num_fractional_digits("-.1e0"), 1);
+        assert_eq!(num_fractional_digits("-.1e2"), 0);
+        assert_eq!(num_fractional_digits("-1.e-3"), 3);
+        assert_eq!(num_fractional_digits("-1.0e-4"), 5);
+        // minus zero int
+        assert_eq!(num_fractional_digits("-0e0"), 0);
+        assert_eq!(num_fractional_digits("-0e-0"), 0);
+        assert_eq!(num_fractional_digits("-0e1"), 0);
+        assert_eq!(num_fractional_digits("-0e+1"), 0);
+        assert_eq!(num_fractional_digits("-0.0e1"), 0);
+        // minus zero float
+        assert_eq!(num_fractional_digits("-0.0"), 1);
+        assert_eq!(num_fractional_digits("-0e-1"), 1);
+        assert_eq!(num_fractional_digits("-0.0e-1"), 2);
+    }
+}
diff --git a/src/uu/seq/src/seq.rs b/src/uu/seq/src/seq.rs
index a76a23c4e..851857ea1 100644
--- a/src/uu/seq/src/seq.rs
+++ b/src/uu/seq/src/seq.rs
@@ -1,170 +1,65 @@
-// TODO: Make -w flag work with decimals
+//  * 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.
 // TODO: Support -f flag
-
-// spell-checker:ignore (ToDO) istr chiter argptr ilen
-
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, AppSettings, Arg};
-use num_bigint::BigInt;
-use num_traits::One;
-use num_traits::Zero;
-use num_traits::{Num, ToPrimitive};
-use std::cmp;
+// spell-checker:ignore (ToDO) istr chiter argptr ilen extendedbigdecimal extendedbigint numberparse
 use std::io::{stdout, ErrorKind, Write};
-use std::str::FromStr;
+use std::process::exit;
 
-mod digits;
-use crate::digits::num_fractional_digits;
-use crate::digits::num_integral_digits;
+use clap::{crate_version, Arg, Command};
+use num_traits::Zero;
 
-use uucore::display::Quotable;
+use uucore::error::FromIo;
+use uucore::error::UResult;
+use uucore::format_usage;
+use uucore::memo::Memo;
+use uucore::show;
+
+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;
 
 static ABOUT: &str = "Display numbers from FIRST to LAST, in steps of INCREMENT.";
+const USAGE: &str = "\
+    {} [OPTION]... LAST
+    {} [OPTION]... FIRST LAST
+    {} [OPTION]... FIRST INCREMENT LAST";
 static OPT_SEPARATOR: &str = "separator";
 static OPT_TERMINATOR: &str = "terminator";
 static OPT_WIDTHS: &str = "widths";
+static OPT_FORMAT: &str = "format";
 
 static ARG_NUMBERS: &str = "numbers";
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... LAST
-    {0} [OPTION]... FIRST LAST
-    {0} [OPTION]... FIRST INCREMENT LAST",
-        uucore::execution_phrase()
-    )
-}
 #[derive(Clone)]
-struct SeqOptions {
+struct SeqOptions<'a> {
     separator: String,
     terminator: String,
     widths: bool,
-}
-
-enum Number {
-    /// Negative zero, as if it were an integer.
-    MinusZero,
-    BigInt(BigInt),
-    F64(f64),
-}
-
-impl Number {
-    fn is_zero(&self) -> bool {
-        match self {
-            Number::MinusZero => true,
-            Number::BigInt(n) => n.is_zero(),
-            Number::F64(n) => n.is_zero(),
-        }
-    }
-
-    fn into_f64(self) -> f64 {
-        match self {
-            Number::MinusZero => -0.,
-            // BigInt::to_f64() can not return None.
-            Number::BigInt(n) => n.to_f64().unwrap(),
-            Number::F64(n) => n,
-        }
-    }
-
-    /// Convert this number into a bigint, consuming it.
-    ///
-    /// For floats, this returns the [`BigInt`] corresponding to the
-    /// floor of the number.
-    fn into_bigint(self) -> BigInt {
-        match self {
-            Number::MinusZero => BigInt::zero(),
-            Number::F64(x) => BigInt::from(x.floor() as i64),
-            Number::BigInt(n) => n,
-        }
-    }
-}
-
-impl FromStr for Number {
-    type Err = String;
-    fn from_str(mut s: &str) -> Result<Self, Self::Err> {
-        s = s.trim_start();
-        if s.starts_with('+') {
-            s = &s[1..];
-        }
-        let is_neg = s.starts_with('-');
-
-        match s.to_lowercase().find("0x") {
-            Some(i) if i <= 1 => match &s.as_bytes()[i + 2] {
-                    b'-' | b'+' => Err(format!(
-                    "invalid hexadecimal argument: {}\nTry '{} --help' for more information.",
-                    s.quote(),
-                    uucore::execution_phrase(),
-                )),
-                    // TODO: hexadecimal floating point parsing (see #2660)
-                    b'.' => Err(format!(
-                    "NotImplemented: hexadecimal floating point numbers: {}\nTry '{} --help' for more information.",
-                    s.quote(),
-                    uucore::execution_phrase(),
-                )),
-                    _ => {
-                        let num = BigInt::from_str_radix(&s[i + 2..], 16)
-                            .map_err(|_| format!(
-                    "invalid hexadecimal argument: {}\nTry '{} --help' for more information.",
-                    s.quote(),
-                    uucore::execution_phrase(),
-                ))?;
-                        match (is_neg, num == BigInt::zero()) {
-                            (true, true) => Ok(Number::MinusZero),
-                            (true, false) => Ok(Number::BigInt(-num)),
-                            (false, _) => Ok(Number::BigInt(num)),
-                        }
-                    }
-                },
-            Some(_) => Err(format!(
-                "invalid hexadecimal argument: {}\nTry '{} --help' for more information.",
-                s.quote(),
-                uucore::execution_phrase(),
-            )),
-
-            None => match s.parse::<BigInt>() {
-                Ok(n) => {
-                    // If `s` is '-0', then `parse()` returns
-                    // `BigInt::zero()`, but we need to return
-                    // `Number::MinusZero` instead.
-                    if n == BigInt::zero() && is_neg {
-                        Ok(Number::MinusZero)
-                    } else {
-                        Ok(Number::BigInt(n))
-                    }
-                }
-                Err(_) => match s.parse::<f64>() {
-                    Ok(value) if value.is_nan() => Err(format!(
-                    "invalid 'not-a-number' argument: {}\nTry '{} --help' for more information.",
-                    s.quote(),
-                    uucore::execution_phrase(),
-                )),
-                    Ok(value) => Ok(Number::F64(value)),
-                    Err(_) => Err(format!(
-                    "invalid floating point argument: {}\nTry '{} --help' for more information.",
-                    s.quote(),
-                    uucore::execution_phrase(),
-                )),
-                },
-            },
-        }
-    }
+    format: Option<&'a str>,
 }
 
 /// A range of integers.
 ///
 /// The elements are (first, increment, last).
-type RangeInt = (BigInt, BigInt, BigInt);
+type RangeInt = (ExtendedBigInt, ExtendedBigInt, ExtendedBigInt);
 
-/// A range of f64.
+/// A range of floats.
 ///
 /// The elements are (first, increment, last).
-type RangeF64 = (f64, f64, f64);
+type RangeFloat = (ExtendedBigDecimal, ExtendedBigDecimal, ExtendedBigDecimal);
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let numbers = matches.values_of(ARG_NUMBERS).unwrap().collect::<Vec<_>>();
 
@@ -172,164 +67,128 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         separator: matches.value_of(OPT_SEPARATOR).unwrap_or("\n").to_string(),
         terminator: matches.value_of(OPT_TERMINATOR).unwrap_or("\n").to_string(),
         widths: matches.is_present(OPT_WIDTHS),
+        format: matches.value_of(OPT_FORMAT),
     };
 
-    let mut largest_dec = 0;
-    let mut padding = 0;
     let first = if numbers.len() > 1 {
-        let slice = numbers[0];
-        largest_dec = num_fractional_digits(slice).unwrap_or_else(|_| {
-            crash!(
-                1,
-                "invalid floating point argument: {}\n Try '{} --help' for more information.",
-                slice.quote(),
-                uucore::execution_phrase()
-            )
-        });
-        padding = num_integral_digits(slice).unwrap_or_else(|_| {
-            crash!(
-                1,
-                "invalid floating point argument: {}\n Try '{} --help' for more information.",
-                slice.quote(),
-                uucore::execution_phrase()
-            )
-        });
-        crash_if_err!(1, slice.parse())
+        match numbers[0].parse() {
+            Ok(num) => num,
+            Err(e) => return Err(SeqError::ParseError(numbers[0].to_string(), e).into()),
+        }
     } else {
-        Number::BigInt(BigInt::one())
+        PreciseNumber::one()
     };
     let increment = if numbers.len() > 2 {
-        let slice = numbers[1];
-        let dec = num_fractional_digits(slice).unwrap_or_else(|_| {
-            crash!(
-                1,
-                "invalid floating point argument: {}\n Try '{} --help' for more information.",
-                slice.quote(),
-                uucore::execution_phrase()
-            )
-        });
-        let int_digits = num_integral_digits(slice).unwrap_or_else(|_| {
-            crash!(
-                1,
-                "invalid floating point argument: {}\n Try '{} --help' for more information.",
-                slice.quote(),
-                uucore::execution_phrase()
-            )
-        });
-        largest_dec = cmp::max(largest_dec, dec);
-        padding = cmp::max(padding, int_digits);
-        crash_if_err!(1, slice.parse())
+        match numbers[1].parse() {
+            Ok(num) => num,
+            Err(e) => return Err(SeqError::ParseError(numbers[1].to_string(), e).into()),
+        }
     } else {
-        Number::BigInt(BigInt::one())
+        PreciseNumber::one()
     };
     if increment.is_zero() {
-        show_error!(
-            "invalid Zero increment value: '{}'\nTry '{} --help' for more information.",
-            numbers[1],
-            uucore::execution_phrase()
-        );
-        return 1;
+        return Err(SeqError::ZeroIncrement(numbers[1].to_string()).into());
     }
-    let last: Number = {
-        let slice = numbers[numbers.len() - 1];
-        let int_digits = num_integral_digits(slice).unwrap_or_else(|_| {
-            crash!(
-                1,
-                "invalid floating point argument: {}\n Try '{} --help' for more information.",
-                slice.quote(),
-                uucore::execution_phrase()
-            )
-        });
-        padding = cmp::max(padding, int_digits);
-        crash_if_err!(1, slice.parse())
+    let last: PreciseNumber = {
+        // We are guaranteed that `numbers.len()` is greater than zero
+        // and at most three because of the argument specification in
+        // `uu_app()`.
+        let n: usize = numbers.len();
+        match numbers[n - 1].parse() {
+            Ok(num) => num,
+            Err(e) => return Err(SeqError::ParseError(numbers[n - 1].to_string(), e).into()),
+        }
     };
 
-    let is_negative_zero_f64 = |x: f64| x == -0.0 && x.is_sign_negative() && largest_dec == 0;
-    let result = match (first, last, increment) {
-        // For example, `seq -0 1 2` or `seq -0 1 2.0`.
-        (Number::MinusZero, last, Number::BigInt(increment)) => print_seq_integers(
-            (BigInt::zero(), increment, last.into_bigint()),
-            options.separator,
-            options.terminator,
-            options.widths,
-            padding,
-            true,
-        ),
-        // For example, `seq -0e0 1 2` or `seq -0e0 1 2.0`.
-        (Number::F64(x), last, Number::BigInt(increment)) if is_negative_zero_f64(x) => {
+    let padding = first
+        .num_integral_digits
+        .max(increment.num_integral_digits)
+        .max(last.num_integral_digits);
+    let largest_dec = first
+        .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(
-                (BigInt::zero(), increment, last.into_bigint()),
-                options.separator,
-                options.terminator,
+                (first, increment, last),
+                &options.separator,
+                &options.terminator,
                 options.widths,
                 padding,
-                true,
+                options.format,
             )
         }
-        // For example, `seq 0 1 2` or `seq 0 1 2.0`.
-        (Number::BigInt(first), last, Number::BigInt(increment)) => print_seq_integers(
-            (first, increment, last.into_bigint()),
-            options.separator,
-            options.terminator,
-            options.widths,
-            padding,
-            false,
-        ),
-        // For example, `seq 0 0.5 1` or `seq 0.0 0.5 1` or `seq 0.0 0.5 1.0`.
-        (first, last, increment) => print_seq(
-            (first.into_f64(), increment.into_f64(), last.into_f64()),
+        (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.separator,
+            &options.terminator,
             options.widths,
             padding,
+            options.format,
         ),
     };
     match result {
-        Ok(_) => 0,
-        Err(err) if err.kind() == ErrorKind::BrokenPipe => 0,
-        Err(_) => 1,
+        Ok(_) => Ok(()),
+        Err(err) if err.kind() == ErrorKind::BrokenPipe => Ok(()),
+        Err(e) => Err(e.map_err_context(|| "write error".into())),
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
-        .setting(AppSettings::AllowLeadingHyphen)
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .trailing_var_arg(true)
+        .allow_negative_numbers(true)
+        .infer_long_args(true)
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .arg(
-            Arg::with_name(OPT_SEPARATOR)
-                .short("s")
+            Arg::new(OPT_SEPARATOR)
+                .short('s')
                 .long("separator")
                 .help("Separator character (defaults to \\n)")
                 .takes_value(true)
                 .number_of_values(1),
         )
         .arg(
-            Arg::with_name(OPT_TERMINATOR)
-                .short("t")
+            Arg::new(OPT_TERMINATOR)
+                .short('t')
                 .long("terminator")
                 .help("Terminator character (defaults to \\n)")
                 .takes_value(true)
                 .number_of_values(1),
         )
         .arg(
-            Arg::with_name(OPT_WIDTHS)
-                .short("w")
+            Arg::new(OPT_WIDTHS)
+                .short('w')
                 .long("widths")
                 .help("Equalize widths of all numbers by padding with zeros"),
         )
         .arg(
-            Arg::with_name(ARG_NUMBERS)
-                .multiple(true)
+            Arg::new(OPT_FORMAT)
+                .short('f')
+                .long(OPT_FORMAT)
+                .help("use printf style floating-point FORMAT")
+                .takes_value(true)
+                .number_of_values(1),
+        )
+        .arg(
+            Arg::new(ARG_NUMBERS)
+                .multiple_occurrences(true)
                 .takes_value(true)
-                .allow_hyphen_values(true)
                 .max_values(3)
                 .required(true),
         )
 }
 
-fn done_printing<T: Num + PartialOrd>(next: &T, increment: &T, last: &T) -> bool {
+fn done_printing<T: Zero + PartialOrd>(next: &T, increment: &T, last: &T) -> bool {
     if increment >= &T::zero() {
         next > last
     } else {
@@ -337,42 +196,112 @@ fn done_printing<T: Num + PartialOrd>(next: &T, increment: &T, last: &T) -> bool
     }
 }
 
+/// Write a big decimal formatted according to the given parameters.
+fn write_value_float(
+    writer: &mut impl Write,
+    value: &ExtendedBigDecimal,
+    width: usize,
+    precision: usize,
+    _is_first_iteration: bool,
+) -> std::io::Result<()> {
+    let value_as_str =
+        if *value == ExtendedBigDecimal::Infinity || *value == ExtendedBigDecimal::MinusInfinity {
+            format!(
+                "{value:>width$.precision$}",
+                value = value,
+                width = width,
+                precision = precision,
+            )
+        } else {
+            format!(
+                "{value:>0width$.precision$}",
+                value = value,
+                width = width,
+                precision = precision,
+            )
+        };
+    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,
+    is_first_iteration: bool,
+) -> std::io::Result<()> {
+    let value_as_str = if pad {
+        if *value == ExtendedBigInt::MinusZero && is_first_iteration {
+            format!("-{value:>0width$}", value = value, width = width - 1,)
+        } else {
+            format!("{value:>0width$}", value = value, width = width,)
+        }
+    } else if *value == ExtendedBigInt::MinusZero && is_first_iteration {
+        format!("-{}", value)
+    } 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: RangeF64,
+    range: RangeFloat,
     largest_dec: usize,
-    separator: String,
-    terminator: String,
+    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 i = 0isize;
-    let is_first_minus_zero = first == -0.0 && first.is_sign_negative();
-    let mut value = first + i as f64 * increment;
+    let mut value = first;
     let padding = if pad { padding + 1 + largest_dec } else { 0 };
     let mut is_first_iteration = true;
     while !done_printing(&value, &increment, &last) {
         if !is_first_iteration {
             write!(stdout, "{}", separator)?;
         }
-        let mut width = padding;
-        if is_first_iteration && is_first_minus_zero {
-            write!(stdout, "-")?;
-            width -= 1;
+        // If there was an argument `-f FORMAT`, then use that format
+        // template instead of the default formatting strategy.
+        //
+        // The `Memo::run_all()` function takes in the template and
+        // the current value and writes the result to `stdout`.
+        //
+        // TODO The `run_all()` method takes a string as its second
+        // parameter but we have an `ExtendedBigDecimal`. In order to
+        // satisfy the signature of the function, we convert the
+        // `ExtendedBigDecimal` into a string. The `Memo::run_all()`
+        // logic will subsequently parse that string into something
+        // similar to an `ExtendedBigDecimal` again before rendering
+        // 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 {
+            Some(f) => {
+                let s = format!("{}", value);
+                if let Err(x) = Memo::run_all(f, &[s]) {
+                    show!(x);
+                    exit(1);
+                }
+            }
+            None => write_value_float(
+                &mut stdout,
+                &value,
+                padding,
+                largest_dec,
+                is_first_iteration,
+            )?,
         }
+        // TODO Implement augmenting addition.
+        value = value + increment.clone();
         is_first_iteration = false;
-        write!(
-            stdout,
-            "{value:>0width$.precision$}",
-            value = value,
-            width = width,
-            precision = largest_dec,
-        )?;
-        i += 1;
-        value = first + i as f64 * increment;
     }
     if !is_first_iteration {
         write!(stdout, "{}", terminator)?;
@@ -397,11 +326,11 @@ fn print_seq(
 /// numbers). Only set this to `true` if `first` is actually zero.
 fn print_seq_integers(
     range: RangeInt,
-    separator: String,
-    terminator: String,
+    separator: &str,
+    terminator: &str,
     pad: bool,
     padding: usize,
-    is_first_minus_zero: bool,
+    format: Option<&str>,
 ) -> std::io::Result<()> {
     let stdout = stdout();
     let mut stdout = stdout.lock();
@@ -412,18 +341,26 @@ fn print_seq_integers(
         if !is_first_iteration {
             write!(stdout, "{}", separator)?;
         }
-        let mut width = padding;
-        if is_first_iteration && is_first_minus_zero {
-            write!(stdout, "-")?;
-            width -= 1;
+        // If there was an argument `-f FORMAT`, then use that format
+        // template instead of the default formatting strategy.
+        //
+        // The `Memo::run_all()` 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) = Memo::run_all(f, &[s]) {
+                    show!(x);
+                    exit(1);
+                }
+            }
+            None => write_value_int(&mut stdout, &value, padding, pad, is_first_iteration)?,
         }
+        // TODO Implement augmenting addition.
+        value = value + increment.clone();
         is_first_iteration = false;
-        if pad {
-            write!(stdout, "{number:>0width$}", number = value, width = width)?;
-        } else {
-            write!(stdout, "{}", value)?;
-        }
-        value += &increment;
     }
 
     if !is_first_iteration {
diff --git a/src/uu/shred/Cargo.toml b/src/uu/shred/Cargo.toml
index 00356d701..6f92de22a 100644
--- a/src/uu/shred/Cargo.toml
+++ b/src/uu/shred/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_shred"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shred ~ (uutils) hide former FILE contents with repeated overwrites"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/shred"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/shred"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,16 +15,10 @@ edition = "2018"
 path = "src/shred.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-rand = "0.7"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+rand = "0.8"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "shred"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/shred/LICENSE b/src/uu/shred/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/shred/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/shred/src/main.rs b/src/uu/shred/src/main.rs
index ea7a42f65..c3525c15e 100644
--- a/src/uu/shred/src/main.rs
+++ b/src/uu/shred/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_shred);
+uucore::bin!(uu_shred);
diff --git a/src/uu/shred/src/shred.rs b/src/uu/shred/src/shred.rs
index fa455f027..05c8d1805 100644
--- a/src/uu/shred/src/shred.rs
+++ b/src/uu/shred/src/shred.rs
@@ -8,7 +8,7 @@
 
 // spell-checker:ignore (words) writeback wipesync
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use rand::prelude::SliceRandom;
 use rand::Rng;
 use std::cell::{Cell, RefCell};
@@ -19,7 +19,8 @@ use std::io::prelude::*;
 use std::io::SeekFrom;
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::{util_name, InvalidEncodingHandling};
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::{format_usage, util_name, InvalidEncodingHandling};
 
 #[macro_use]
 extern crate uucore;
@@ -67,9 +68,9 @@ struct FilenameGenerator {
 }
 
 impl FilenameGenerator {
-    fn new(name_len: usize) -> FilenameGenerator {
+    fn new(name_len: usize) -> Self {
         let indices: Vec<usize> = vec![0; name_len];
-        FilenameGenerator {
+        Self {
             name_len,
             name_charset_indices: RefCell::new(indices),
             exhausted: Cell::new(false),
@@ -95,7 +96,7 @@ impl Iterator for FilenameGenerator {
         }
 
         if name_charset_indices[0] == NAME_CHARSET.len() - 1 {
-            self.exhausted.set(true)
+            self.exhausted.set(true);
         }
         // Now increment the least significant index
         for i in (0..self.name_len).rev() {
@@ -213,10 +214,7 @@ impl<'a> BytesGenerator<'a> {
 static ABOUT: &str = "Overwrite the specified FILE(s) repeatedly, in order to make it harder\n\
 for even very expensive hardware probing to recover the data.
 ";
-
-fn usage() -> String {
-    format!("{} [OPTION]... FILE...", uucore::execution_phrase())
-}
+const USAGE: &str = "{} [OPTION]... FILE...";
 
 static AFTER_HELP: &str =
     "Delete FILE(s) if --remove (-u) is specified.  The default is not to remove\n\
@@ -266,31 +264,26 @@ pub mod options {
     pub const ZERO: &str = "zero";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
-    let usage = usage();
-
-    let app = uu_app().usage(&usage[..]);
-
-    let matches = app.get_matches_from(args);
-
-    let mut errs: Vec<String> = vec![];
+    let matches = uu_app().get_matches_from(args);
 
     if !matches.is_present(options::FILE) {
-        show_error!("Missing an argument");
-        show_error!("For help, try '{} --help'", uucore::execution_phrase());
-        return 0;
+        return Err(UUsageError::new(1, "missing file operand"));
     }
 
     let iterations = match matches.value_of(options::ITERATIONS) {
         Some(s) => match s.parse::<usize>() {
             Ok(u) => u,
             Err(_) => {
-                errs.push(format!("invalid number of passes: {}", s.quote()));
-                0
+                return Err(USimpleError::new(
+                    1,
+                    format!("invalid number of passes: {}", s.quote()),
+                ))
             }
         },
         None => unreachable!(),
@@ -313,79 +306,76 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     let zero = matches.is_present(options::ZERO);
     let verbose = matches.is_present(options::VERBOSE);
 
-    if !errs.is_empty() {
-        show_error!("Invalid arguments supplied.");
-        for message in errs {
-            show_error!("{}", message);
-        }
-        return 1;
-    }
-
     for path_str in matches.values_of(options::FILE).unwrap() {
-        wipe_file(
+        show_if_err!(wipe_file(
             path_str, iterations, remove, size, exact, zero, verbose, force,
-        );
+        ));
     }
-
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::FORCE)
+            Arg::new(options::FORCE)
                 .long(options::FORCE)
-                .short("f")
+                .short('f')
                 .help("change permissions to allow writing if necessary"),
         )
         .arg(
-            Arg::with_name(options::ITERATIONS)
+            Arg::new(options::ITERATIONS)
                 .long(options::ITERATIONS)
-                .short("n")
+                .short('n')
                 .help("overwrite N times instead of the default (3)")
                 .value_name("NUMBER")
                 .default_value("3"),
         )
         .arg(
-            Arg::with_name(options::SIZE)
+            Arg::new(options::SIZE)
                 .long(options::SIZE)
-                .short("s")
+                .short('s')
                 .takes_value(true)
                 .value_name("N")
                 .help("shred this many bytes (suffixes like K, M, G accepted)"),
         )
         .arg(
-            Arg::with_name(options::REMOVE)
-                .short("u")
+            Arg::new(options::REMOVE)
+                .short('u')
                 .long(options::REMOVE)
                 .help("truncate and remove file after overwriting;  See below"),
         )
         .arg(
-            Arg::with_name(options::VERBOSE)
+            Arg::new(options::VERBOSE)
                 .long(options::VERBOSE)
-                .short("v")
+                .short('v')
                 .help("show progress"),
         )
         .arg(
-            Arg::with_name(options::EXACT)
+            Arg::new(options::EXACT)
                 .long(options::EXACT)
-                .short("x")
+                .short('x')
                 .help(
                     "do not round file sizes up to the next full block;\n\
                      this is the default for non-regular files",
                 ),
         )
         .arg(
-            Arg::with_name(options::ZERO)
+            Arg::new(options::ZERO)
                 .long(options::ZERO)
-                .short("z")
+                .short('z')
                 .help("add a final overwrite with zeros to hide shredding"),
         )
         // Positional arguments
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .arg(
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
 }
 
 // TODO: Add support for all postfixes here up to and including EiB
@@ -419,7 +409,7 @@ fn get_size(size_str_opt: Option<String>) -> Option<u64> {
                 util_name(),
                 size_str_opt.unwrap().maybe_quote()
             );
-            exit!(1);
+            std::process::exit(1);
         }
     };
 
@@ -452,34 +442,28 @@ fn wipe_file(
     zero: bool,
     verbose: bool,
     force: bool,
-) {
+) -> UResult<()> {
     // Get these potential errors out of the way first
     let path: &Path = Path::new(path_str);
     if !path.exists() {
-        show_error!("{}: No such file or directory", path.maybe_quote());
-        return;
+        return Err(USimpleError::new(
+            1,
+            format!("{}: No such file or directory", path.maybe_quote()),
+        ));
     }
     if !path.is_file() {
-        show_error!("{}: Not a file", path.maybe_quote());
-        return;
+        return Err(USimpleError::new(
+            1,
+            format!("{}: Not a file", path.maybe_quote()),
+        ));
     }
 
     // If force is true, set file permissions to not-readonly.
     if force {
-        let metadata = match fs::metadata(path) {
-            Ok(m) => m,
-            Err(e) => {
-                show_error!("{}", e);
-                return;
-            }
-        };
-
+        let metadata = fs::metadata(path).map_err_context(String::new)?;
         let mut perms = metadata.permissions();
         perms.set_readonly(false);
-        if let Err(e) = fs::set_permissions(path, perms) {
-            show_error!("{}", e);
-            return;
-        }
+        fs::set_permissions(path, perms).map_err_context(String::new)?;
     }
 
     // Fill up our pass sequence
@@ -488,7 +472,7 @@ fn wipe_file(
     if n_passes <= 3 {
         // Only random passes if n_passes <= 3
         for _ in 0..n_passes {
-            pass_sequence.push(PassType::Random)
+            pass_sequence.push(PassType::Random);
         }
     }
     // First fill it with Patterns, shuffle it, then evenly distribute Random
@@ -521,13 +505,11 @@ fn wipe_file(
 
     {
         let total_passes: usize = pass_sequence.len();
-        let mut file: File = match OpenOptions::new().write(true).truncate(false).open(path) {
-            Ok(f) => f,
-            Err(e) => {
-                show_error!("{}: failed to open for writing: {}", path.maybe_quote(), e);
-                return;
-            }
-        };
+        let mut file: File = OpenOptions::new()
+            .write(true)
+            .truncate(false)
+            .open(path)
+            .map_err_context(|| format!("{}: failed to open for writing", path.maybe_quote()))?;
 
         // NOTE: it does not really matter what we set for total_bytes and gen_type here, so just
         //       use bogus values
@@ -557,24 +539,17 @@ fn wipe_file(
                 }
             }
             // size is an optional argument for exactly how many bytes we want to shred
-            match do_pass(&mut file, path, &mut generator, *pass_type, size) {
-                Ok(_) => {}
-                Err(e) => {
-                    show_error!("{}: File write pass failed: {}", path.maybe_quote(), e);
-                }
-            }
+            show_if_err!(do_pass(&mut file, path, &mut generator, *pass_type, size)
+                .map_err_context(|| format!("{}: File write pass failed", path.maybe_quote())));
             // Ignore failed writes; just keep trying
         }
     }
 
     if remove {
-        match do_remove(path, path_str, verbose) {
-            Ok(_) => {}
-            Err(e) => {
-                show_error!("{}: failed to remove file: {}", path.maybe_quote(), e);
-            }
-        }
+        do_remove(path, path_str, verbose)
+            .map_err_context(|| format!("{}: failed to remove file", path.maybe_quote()))?;
     }
+    Ok(())
 }
 
 fn do_pass<'a>(
diff --git a/src/uu/shuf/BENCHMARKING.md b/src/uu/shuf/BENCHMARKING.md
new file mode 100644
index 000000000..7607f04b4
--- /dev/null
+++ b/src/uu/shuf/BENCHMARKING.md
@@ -0,0 +1,28 @@
+# Benchmarking shuf
+
+`shuf` is a simple utility, but there are at least two important cases
+benchmark: with and without repetition.
+
+When benchmarking changes, make sure to always build with the `--release` flag.
+You can compare with another branch by compiling on that branch and than
+renaming the executable from `shuf` to `shuf.old`.
+
+## Without repetition
+
+By default, `shuf` samples without repetition. To benchmark only the
+randomization and not IO, we can pass the `-i` flag with a range of numbers to
+randomly sample from. An example of a command that works well for testing:
+
+```shell
+hyperfine --warmup 10 "target/release/shuf -i 0-10000000"
+```
+
+## With repetition
+
+When repetition is allowed, `shuf` works very differently under the hood, so it
+should be benchmarked separately. In this case we have to pass the `-n` flag or
+the command will run forever. An example of a hyperfine command is
+
+```shell
+hyperfine --warmup 10 "target/release/shuf -r -n 10000000 -i 0-1000"
+```
diff --git a/src/uu/shuf/Cargo.toml b/src/uu/shuf/Cargo.toml
index 35da41145..61326e985 100644
--- a/src/uu/shuf/Cargo.toml
+++ b/src/uu/shuf/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_shuf"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "shuf ~ (uutils) display random permutations of input lines"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/shuf"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/shuf"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,11 @@ edition = "2018"
 path = "src/shuf.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-rand = "0.5"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+rand = "0.8"
+rand_core = "0.6"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "shuf"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/shuf/LICENSE b/src/uu/shuf/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/shuf/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/shuf/src/main.rs b/src/uu/shuf/src/main.rs
index fc6e2b4ae..8214db209 100644
--- a/src/uu/shuf/src/main.rs
+++ b/src/uu/shuf/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_shuf);
+uucore::bin!(uu_shuf);
diff --git a/src/uu/shuf/src/rand_read_adapter.rs b/src/uu/shuf/src/rand_read_adapter.rs
new file mode 100644
index 000000000..fd8998c10
--- /dev/null
+++ b/src/uu/shuf/src/rand_read_adapter.rs
@@ -0,0 +1,144 @@
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A wrapper around any Read to treat it as an RNG.
+
+use std::fmt;
+use std::io::Read;
+
+use rand_core::{impls, Error, RngCore};
+
+/// An RNG that reads random bytes straight from any type supporting
+/// [`std::io::Read`], for example files.
+///
+/// This will work best with an infinite reader, but that is not required.
+///
+/// This can be used with `/dev/urandom` on Unix but it is recommended to use
+/// [`OsRng`] instead.
+///
+/// # Panics
+///
+/// `ReadRng` uses [`std::io::Read::read_exact`], which retries on interrupts.
+/// All other errors from the underlying reader, including when it does not
+/// have enough data, will only be reported through [`try_fill_bytes`].
+/// The other [`RngCore`] methods will panic in case of an error.
+///
+/// [`OsRng`]: rand::rngs::OsRng
+/// [`try_fill_bytes`]: RngCore::try_fill_bytes
+#[derive(Debug)]
+pub struct ReadRng<R> {
+    reader: R,
+}
+
+impl<R: Read> ReadRng<R> {
+    /// Create a new `ReadRng` from a `Read`.
+    pub fn new(r: R) -> Self {
+        Self { reader: r }
+    }
+}
+
+impl<R: Read> RngCore for ReadRng<R> {
+    fn next_u32(&mut self) -> u32 {
+        impls::next_u32_via_fill(self)
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        impls::next_u64_via_fill(self)
+    }
+
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.try_fill_bytes(dest).unwrap_or_else(|err| {
+            panic!(
+                "reading random bytes from Read implementation failed; error: {}",
+                err
+            );
+        });
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        if dest.is_empty() {
+            return Ok(());
+        }
+        // Use `std::io::read_exact`, which retries on `ErrorKind::Interrupted`.
+        self.reader
+            .read_exact(dest)
+            .map_err(|e| Error::new(ReadError(e)))
+    }
+}
+
+/// `ReadRng` error type
+#[derive(Debug)]
+pub struct ReadError(std::io::Error);
+
+impl fmt::Display for ReadError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "ReadError: {}", self.0)
+    }
+}
+
+impl std::error::Error for ReadError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.0)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::println;
+
+    use super::ReadRng;
+    use rand::RngCore;
+
+    #[test]
+    fn test_reader_rng_u64() {
+        // transmute from the target to avoid endianness concerns.
+        #[rustfmt::skip]
+        let v = [0u8, 0, 0, 0, 0, 0, 0, 1,
+                 0,   4, 0, 0, 3, 0, 0, 2,
+                 5,   0, 0, 0, 0, 0, 0, 0];
+        let mut rng = ReadRng::new(&v[..]);
+
+        assert_eq!(rng.next_u64(), 1 << 56);
+        assert_eq!(rng.next_u64(), (2 << 56) + (3 << 32) + (4 << 8));
+        assert_eq!(rng.next_u64(), 5);
+    }
+
+    #[test]
+    fn test_reader_rng_u32() {
+        let v = [0u8, 0, 0, 1, 0, 0, 2, 0, 3, 0, 0, 0];
+        let mut rng = ReadRng::new(&v[..]);
+
+        assert_eq!(rng.next_u32(), 1 << 24);
+        assert_eq!(rng.next_u32(), 2 << 16);
+        assert_eq!(rng.next_u32(), 3);
+    }
+
+    #[test]
+    fn test_reader_rng_fill_bytes() {
+        let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
+        let mut w = [0u8; 8];
+
+        let mut rng = ReadRng::new(&v[..]);
+        rng.fill_bytes(&mut w);
+
+        assert!(v == w);
+    }
+
+    #[test]
+    fn test_reader_rng_insufficient_bytes() {
+        let v = [1u8, 2, 3, 4, 5, 6, 7, 8];
+        let mut w = [0u8; 9];
+
+        let mut rng = ReadRng::new(&v[..]);
+
+        let result = rng.try_fill_bytes(&mut w);
+        assert!(result.is_err());
+        println!("Error: {}", result.unwrap_err());
+    }
+}
diff --git a/src/uu/shuf/src/shuf.rs b/src/uu/shuf/src/shuf.rs
index 9a899d746..0b62ec84a 100644
--- a/src/uu/shuf/src/shuf.rs
+++ b/src/uu/shuf/src/shuf.rs
@@ -7,15 +7,16 @@
 
 // spell-checker:ignore (ToDO) cmdline evec seps rvec fdata
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
-use rand::Rng;
+use clap::{crate_version, Arg, Command, Values};
+use rand::prelude::SliceRandom;
+use rand::RngCore;
 use std::fs::File;
 use std::io::{stdin, stdout, BufReader, BufWriter, Read, Write};
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::{format_usage, InvalidEncodingHandling};
+
+mod rand_read_adapter;
 
 enum Mode {
     Default(String),
@@ -24,14 +25,14 @@ enum Mode {
 }
 
 static NAME: &str = "shuf";
-static USAGE: &str = r#"shuf [OPTION]... [FILE]
-  or:  shuf -e [OPTION]... [ARG]...
-  or:  shuf -i LO-HI [OPTION]...
-Write a random permutation of the input lines to standard output.
-
-With no FILE, or when FILE is -, read standard input.
-"#;
-static TEMPLATE: &str = "Usage: {usage}\nMandatory arguments to long options are mandatory for short options too.\n{unified}";
+static USAGE: &str = "\
+    {} [OPTION]... [FILE]
+    {} -e [OPTION]... [ARG]...
+    {} -i LO-HI [OPTION]...";
+static ABOUT: &str = "\
+    Shuffle the input by outputting a random permutation of input lines.\
+    Each output permutation is equally likely.\
+    With no FILE, or when FILE is -, read standard input.";
 
 struct Options {
     head_count: usize,
@@ -52,7 +53,8 @@ mod options {
     pub static FILE: &str = "file";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -65,7 +67,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         match parse_range(range) {
             Ok(m) => Mode::InputRange(m),
             Err(msg) => {
-                crash!(1, "{}", msg);
+                return Err(USimpleError::new(1, msg));
             }
         }
     } else {
@@ -73,15 +75,13 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     };
 
     let options = Options {
-        head_count: match matches.value_of(options::HEAD_COUNT) {
-            Some(count) => match count.parse::<usize>() {
+        head_count: {
+            let mut headcounts: Values<'_> =
+                matches.values_of(options::HEAD_COUNT).unwrap_or_default();
+            match parse_head_count(&mut headcounts) {
                 Ok(val) => val,
-                Err(_) => {
-                    show_error!("invalid line count: {}", count.quote());
-                    return 1;
-                }
-            },
-            None => std::usize::MAX,
+                Err(msg) => return Err(USimpleError::new(1, msg)),
+            }
         },
         output: matches.value_of(options::OUTPUT).map(String::from),
         random_source: matches.value_of(options::RANDOM_SOURCE).map(String::from),
@@ -97,45 +97,46 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         Mode::Echo(args) => {
             let mut evec = args.iter().map(String::as_bytes).collect::<Vec<_>>();
             find_seps(&mut evec, options.sep);
-            shuf_bytes(&mut evec, options);
+            shuf_bytes(&mut evec, options)?;
         }
         Mode::InputRange((b, e)) => {
             let rvec = (b..e).map(|x| format!("{}", x)).collect::<Vec<String>>();
             let mut rvec = rvec.iter().map(String::as_bytes).collect::<Vec<&[u8]>>();
-            shuf_bytes(&mut rvec, options);
+            shuf_bytes(&mut rvec, options)?;
         }
         Mode::Default(filename) => {
-            let fdata = read_input_file(&filename);
+            let fdata = read_input_file(&filename)?;
             let mut fdata = vec![&fdata[..]];
             find_seps(&mut fdata, options.sep);
-            shuf_bytes(&mut fdata, options);
+            shuf_bytes(&mut fdata, options)?;
         }
     }
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
+        .about(ABOUT)
         .version(crate_version!())
-        .template(TEMPLATE)
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::ECHO)
-                .short("e")
+            Arg::new(options::ECHO)
+                .short('e')
                 .long(options::ECHO)
                 .takes_value(true)
                 .value_name("ARG")
                 .help("treat each ARG as an input line")
-                .multiple(true)
-                .use_delimiter(false)
+                .multiple_occurrences(true)
+                .use_value_delimiter(false)
                 .min_values(0)
                 .conflicts_with(options::INPUT_RANGE),
         )
         .arg(
-            Arg::with_name(options::INPUT_RANGE)
-                .short("i")
+            Arg::new(options::INPUT_RANGE)
+                .short('i')
                 .long(options::INPUT_RANGE)
                 .takes_value(true)
                 .value_name("LO-HI")
@@ -143,59 +144,58 @@ pub fn uu_app() -> App<'static, 'static> {
                 .conflicts_with(options::FILE),
         )
         .arg(
-            Arg::with_name(options::HEAD_COUNT)
-                .short("n")
+            Arg::new(options::HEAD_COUNT)
+                .short('n')
                 .long(options::HEAD_COUNT)
                 .takes_value(true)
+                .multiple_occurrences(true)
                 .value_name("COUNT")
                 .help("output at most COUNT lines"),
         )
         .arg(
-            Arg::with_name(options::OUTPUT)
-                .short("o")
+            Arg::new(options::OUTPUT)
+                .short('o')
                 .long(options::OUTPUT)
                 .takes_value(true)
                 .value_name("FILE")
                 .help("write result to FILE instead of standard output"),
         )
         .arg(
-            Arg::with_name(options::RANDOM_SOURCE)
+            Arg::new(options::RANDOM_SOURCE)
                 .long(options::RANDOM_SOURCE)
                 .takes_value(true)
                 .value_name("FILE")
                 .help("get random bytes from FILE"),
         )
         .arg(
-            Arg::with_name(options::REPEAT)
-                .short("r")
+            Arg::new(options::REPEAT)
+                .short('r')
                 .long(options::REPEAT)
                 .help("output lines can be repeated"),
         )
         .arg(
-            Arg::with_name(options::ZERO_TERMINATED)
-                .short("z")
+            Arg::new(options::ZERO_TERMINATED)
+                .short('z')
                 .long(options::ZERO_TERMINATED)
                 .help("line delimiter is NUL, not newline"),
         )
-        .arg(Arg::with_name(options::FILE).takes_value(true))
+        .arg(Arg::new(options::FILE).takes_value(true))
 }
 
-fn read_input_file(filename: &str) -> Vec<u8> {
+fn read_input_file(filename: &str) -> UResult<Vec<u8>> {
     let mut file = BufReader::new(if filename == "-" {
         Box::new(stdin()) as Box<dyn Read>
     } else {
-        match File::open(filename) {
-            Ok(f) => Box::new(f) as Box<dyn Read>,
-            Err(e) => crash!(1, "failed to open {}: {}", filename.quote(), e),
-        }
+        let file = File::open(filename)
+            .map_err_context(|| format!("failed to open {}", filename.quote()))?;
+        Box::new(file) as Box<dyn Read>
     });
 
     let mut data = Vec::new();
-    if let Err(e) = file.read_to_end(&mut data) {
-        crash!(1, "failed reading {}: {}", filename.quote(), e)
-    };
+    file.read_to_end(&mut data)
+        .map_err_context(|| format!("failed reading {}", filename.quote()))?;
 
-    data
+    Ok(data)
 }
 
 fn find_seps(data: &mut Vec<&[u8]>, sep: u8) {
@@ -231,86 +231,113 @@ fn find_seps(data: &mut Vec<&[u8]>, sep: u8) {
     }
 }
 
-fn shuf_bytes(input: &mut Vec<&[u8]>, opts: Options) {
+fn shuf_bytes(input: &mut Vec<&[u8]>, opts: Options) -> UResult<()> {
     let mut output = BufWriter::new(match opts.output {
         None => Box::new(stdout()) as Box<dyn Write>,
-        Some(s) => match File::create(&s[..]) {
-            Ok(f) => Box::new(f) as Box<dyn Write>,
-            Err(e) => crash!(1, "failed to open {} for writing: {}", s.quote(), e),
-        },
+        Some(s) => {
+            let file = File::create(&s[..])
+                .map_err_context(|| format!("failed to open {} for writing", s.quote()))?;
+            Box::new(file) as Box<dyn Write>
+        }
     });
 
     let mut rng = match opts.random_source {
-        Some(r) => WrappedRng::RngFile(rand::rngs::adapter::ReadRng::new(
-            match File::open(&r[..]) {
-                Ok(f) => f,
-                Err(e) => crash!(1, "failed to open random source {}: {}", r.quote(), e),
-            },
-        )),
+        Some(r) => {
+            let file = File::open(&r[..])
+                .map_err_context(|| format!("failed to open random source {}", r.quote()))?;
+            WrappedRng::RngFile(rand_read_adapter::ReadRng::new(file))
+        }
         None => WrappedRng::RngDefault(rand::thread_rng()),
     };
 
-    // we're generating a random usize. To keep things fair, we take this number mod ceil(log2(length+1))
-    let mut len_mod = 1;
-    let mut len = input.len();
-    while len > 0 {
-        len >>= 1;
-        len_mod <<= 1;
+    if input.is_empty() {
+        return Ok(());
     }
 
-    let mut count = opts.head_count;
-    while count > 0 && !input.is_empty() {
-        let mut r = input.len();
-        while r >= input.len() {
-            r = rng.next_usize() % len_mod;
+    if opts.repeat {
+        for _ in 0..opts.head_count {
+            // Returns None is the slice is empty. We checked this before, so
+            // this is safe.
+            let r = input.choose(&mut rng).unwrap();
+
+            output
+                .write_all(r)
+                .map_err_context(|| "write failed".to_string())?;
+            output
+                .write_all(&[opts.sep])
+                .map_err_context(|| "write failed".to_string())?;
         }
-
-        // write the randomly chosen value and the separator
-        output
-            .write_all(input[r])
-            .unwrap_or_else(|e| crash!(1, "write failed: {}", e));
-        output
-            .write_all(&[opts.sep])
-            .unwrap_or_else(|e| crash!(1, "write failed: {}", e));
-
-        // if we do not allow repeats, remove the chosen value from the input vector
-        if !opts.repeat {
-            // shrink the mask if we will drop below a power of 2
-            if input.len() % 2 == 0 && len_mod > 2 {
-                len_mod >>= 1;
-            }
-            input.swap_remove(r);
+    } else {
+        let (shuffled, _) = input.partial_shuffle(&mut rng, opts.head_count);
+        for r in shuffled {
+            output
+                .write_all(r)
+                .map_err_context(|| "write failed".to_string())?;
+            output
+                .write_all(&[opts.sep])
+                .map_err_context(|| "write failed".to_string())?;
         }
-
-        count -= 1;
     }
+
+    Ok(())
 }
 
 fn parse_range(input_range: &str) -> Result<(usize, usize), String> {
-    let split: Vec<&str> = input_range.split('-').collect();
-    if split.len() != 2 {
-        Err(format!("invalid input range: {}", input_range.quote()))
-    } else {
-        let begin = split[0]
+    if let Some((from, to)) = input_range.split_once('-') {
+        let begin = from
             .parse::<usize>()
-            .map_err(|_| format!("invalid input range: {}", split[0].quote()))?;
-        let end = split[1]
+            .map_err(|_| format!("invalid input range: {}", from.quote()))?;
+        let end = to
             .parse::<usize>()
-            .map_err(|_| format!("invalid input range: {}", split[1].quote()))?;
+            .map_err(|_| format!("invalid input range: {}", to.quote()))?;
         Ok((begin, end + 1))
+    } else {
+        Err(format!("invalid input range: {}", input_range.quote()))
     }
 }
 
+fn parse_head_count(headcounts: &mut Values<'_>) -> Result<usize, String> {
+    let mut result = std::usize::MAX;
+    for count in headcounts {
+        match count.parse::<usize>() {
+            Ok(pv) => result = std::cmp::min(result, pv),
+            Err(_) => return Err(format!("invalid line count: {}", count.quote())),
+        }
+    }
+    Ok(result)
+}
+
 enum WrappedRng {
-    RngFile(rand::rngs::adapter::ReadRng<File>),
+    RngFile(rand_read_adapter::ReadRng<File>),
     RngDefault(rand::rngs::ThreadRng),
 }
 
-impl WrappedRng {
-    fn next_usize(&mut self) -> usize {
-        match *self {
-            WrappedRng::RngFile(ref mut r) => r.gen(),
-            WrappedRng::RngDefault(ref mut r) => r.gen(),
+impl RngCore for WrappedRng {
+    fn next_u32(&mut self) -> u32 {
+        match self {
+            Self::RngFile(r) => r.next_u32(),
+            Self::RngDefault(r) => r.next_u32(),
+        }
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        match self {
+            Self::RngFile(r) => r.next_u64(),
+            Self::RngDefault(r) => r.next_u64(),
+        }
+    }
+
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        match self {
+            Self::RngFile(r) => r.fill_bytes(dest),
+            Self::RngDefault(r) => r.fill_bytes(dest),
+        }
+    }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+        match self {
+            Self::RngFile(r) => r.try_fill_bytes(dest),
+            Self::RngDefault(r) => r.try_fill_bytes(dest),
         }
     }
 }
diff --git a/src/uu/sleep/Cargo.toml b/src/uu/sleep/Cargo.toml
index af6f22b9f..0542b3ec8 100644
--- a/src/uu/sleep/Cargo.toml
+++ b/src/uu/sleep/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_sleep"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sleep ~ (uutils) pause for DURATION"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/sleep"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sleep"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/sleep.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "sleep"
diff --git a/src/uu/sleep/LICENSE b/src/uu/sleep/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/sleep/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/sleep/src/main.rs b/src/uu/sleep/src/main.rs
index 16c3100aa..536edbb23 100644
--- a/src/uu/sleep/src/main.rs
+++ b/src/uu/sleep/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_sleep);
+uucore::bin!(uu_sleep);
diff --git a/src/uu/sleep/src/sleep.rs b/src/uu/sleep/src/sleep.rs
index 80e8cd852..4d5095c31 100644
--- a/src/uu/sleep/src/sleep.rs
+++ b/src/uu/sleep/src/sleep.rs
@@ -8,11 +8,17 @@
 use std::thread;
 use std::time::Duration;
 
-use uucore::error::{UResult, USimpleError};
+use uucore::{
+    error::{UResult, UUsageError},
+    format_usage,
+};
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 
 static ABOUT: &str = "Pause for NUMBER seconds.";
+const USAGE: &str = "\
+    {} NUMBER[SUFFIX]...
+    {} OPTION";
 static LONG_HELP: &str = "Pause for NUMBER seconds.  SUFFIX may be 's' for seconds (the default),
 'm' for minutes, 'h' for hours or 'd' for days.  Unlike most implementations
 that require NUMBER be an integer, here NUMBER may be an arbitrary floating
@@ -23,51 +29,42 @@ mod options {
     pub const NUMBER: &str = "NUMBER";
 }
 
-fn usage() -> String {
-    format!(
-        "{0} {1}[SUFFIX]... \n    {0} OPTION",
-        uucore::execution_phrase(),
-        options::NUMBER
-    )
-}
-
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     if let Some(values) = matches.values_of(options::NUMBER) {
-        let numbers = values.collect();
-        return sleep(numbers);
+        let numbers = values.collect::<Vec<_>>();
+        return sleep(&numbers);
     }
 
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::NUMBER)
-                .long(options::NUMBER)
+            Arg::new(options::NUMBER)
                 .help("pause for NUMBER seconds")
                 .value_name(options::NUMBER)
                 .index(1)
-                .multiple(true)
+                .multiple_occurrences(true)
                 .required(true),
         )
 }
 
-fn sleep(args: Vec<&str>) -> UResult<()> {
+fn sleep(args: &[&str]) -> UResult<()> {
     let sleep_dur =
         args.iter().try_fold(
             Duration::new(0, 0),
             |result, arg| match uucore::parse_time::from_str(&arg[..]) {
-                Ok(m) => Ok(m + result),
-                Err(f) => Err(USimpleError::new(1, f)),
+                Ok(m) => Ok(m.saturating_add(result)),
+                Err(f) => Err(UUsageError::new(1, f)),
             },
         )?;
     thread::sleep(sleep_dur);
diff --git a/src/uu/sort/Cargo.toml b/src/uu/sort/Cargo.toml
index b3d4fe0ea..4523c0748 100644
--- a/src/uu/sort/Cargo.toml
+++ b/src/uu/sort/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_sort"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sort ~ (uutils) sort input lines"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/sort"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sort"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -16,19 +16,18 @@ path = "src/sort.rs"
 
 [dependencies]
 binary-heap-plus = "0.4.1"
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 compare = "0.1.0"
 ctrlc = { version = "3.0", features = ["termination"] }
 fnv = "1.0.7"
 itertools = "0.10.0"
 memchr = "2.4.0"
-ouroboros = "0.10.1"
-rand = "0.7"
+ouroboros = "0.15.0"
+rand = "0.8"
 rayon = "1.5"
 tempfile = "3"
 unicode-width = "0.1.8"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "sort"
diff --git a/src/uu/sort/LICENSE b/src/uu/sort/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/sort/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/sort/src/check.rs b/src/uu/sort/src/check.rs
index 5be752be0..3f02a4c31 100644
--- a/src/uu/sort/src/check.rs
+++ b/src/uu/sort/src/check.rs
@@ -40,7 +40,7 @@ pub fn check(path: &OsStr, settings: &GlobalSettings) -> UResult<()> {
     let (loaded_sender, loaded_receiver) = sync_channel(2);
     thread::spawn({
         let settings = settings.clone();
-        move || reader(file, recycled_receiver, loaded_sender, &settings)
+        move || reader(file, &recycled_receiver, &loaded_sender, &settings)
     });
     for _ in 0..2 {
         let _ = recycled_sender.send(RecycledChunk::new(if settings.buffer_size < 100 * 1024 {
@@ -102,14 +102,14 @@ pub fn check(path: &OsStr, settings: &GlobalSettings) -> UResult<()> {
 /// The function running on the reader thread.
 fn reader(
     mut file: Box<dyn Read + Send>,
-    receiver: Receiver<RecycledChunk>,
-    sender: SyncSender<Chunk>,
+    receiver: &Receiver<RecycledChunk>,
+    sender: &SyncSender<Chunk>,
     settings: &GlobalSettings,
 ) -> UResult<()> {
     let mut carry_over = vec![];
     for recycled_chunk in receiver.iter() {
         let should_continue = chunks::read(
-            &sender,
+            sender,
             recycled_chunk,
             None,
             &mut carry_over,
diff --git a/src/uu/sort/src/chunks.rs b/src/uu/sort/src/chunks.rs
index 80d6060d4..d7e795efa 100644
--- a/src/uu/sort/src/chunks.rs
+++ b/src/uu/sort/src/chunks.rs
@@ -100,7 +100,7 @@ pub struct RecycledChunk {
 
 impl RecycledChunk {
     pub fn new(capacity: usize) -> Self {
-        RecycledChunk {
+        Self {
             lines: Vec::new(),
             selections: Vec::new(),
             num_infos: Vec::new(),
@@ -193,16 +193,13 @@ pub fn read<T: Read>(
 
 /// Split `read` into `Line`s, and add them to `lines`.
 fn parse_lines<'a>(
-    mut read: &'a str,
+    read: &'a str,
     lines: &mut Vec<Line<'a>>,
     line_data: &mut LineData<'a>,
     separator: u8,
     settings: &GlobalSettings,
 ) {
-    // Strip a trailing separator. TODO: Once our MinRustV is 1.45 or above, use strip_suffix() instead.
-    if read.ends_with(separator as char) {
-        read = &read[..read.len() - 1];
-    }
+    let read = read.strip_suffix(separator as char).unwrap_or(read);
 
     assert!(lines.is_empty());
     assert!(line_data.selections.is_empty());
diff --git a/src/uu/sort/src/ext_sort.rs b/src/uu/sort/src/ext_sort.rs
index bf332e4e8..fbb9c16d7 100644
--- a/src/uu/sort/src/ext_sort.rs
+++ b/src/uu/sort/src/ext_sort.rs
@@ -50,13 +50,13 @@ pub fn ext_sort(
     let (recycled_sender, recycled_receiver) = std::sync::mpsc::sync_channel(1);
     thread::spawn({
         let settings = settings.clone();
-        move || sorter(recycled_receiver, sorted_sender, settings)
+        move || sorter(&recycled_receiver, &sorted_sender, &settings)
     });
     if settings.compress_prog.is_some() {
         reader_writer::<_, WriteableCompressedTmpFile>(
             files,
             settings,
-            sorted_receiver,
+            &sorted_receiver,
             recycled_sender,
             output,
             tmp_dir,
@@ -65,7 +65,7 @@ pub fn ext_sort(
         reader_writer::<_, WriteablePlainTmpFile>(
             files,
             settings,
-            sorted_receiver,
+            &sorted_receiver,
             recycled_sender,
             output,
             tmp_dir,
@@ -79,7 +79,7 @@ fn reader_writer<
 >(
     files: F,
     settings: &GlobalSettings,
-    receiver: Receiver<Chunk>,
+    receiver: &Receiver<Chunk>,
     sender: SyncSender<Chunk>,
     output: Output,
     tmp_dir: &mut TmpDirWrapper,
@@ -156,10 +156,10 @@ fn reader_writer<
 }
 
 /// The function that is executed on the sorter thread.
-fn sorter(receiver: Receiver<Chunk>, sender: SyncSender<Chunk>, settings: GlobalSettings) {
+fn sorter(receiver: &Receiver<Chunk>, sender: &SyncSender<Chunk>, settings: &GlobalSettings) {
     while let Ok(mut payload) = receiver.recv() {
         payload.with_contents_mut(|contents| {
-            sort_by(&mut contents.lines, &settings, &contents.line_data)
+            sort_by(&mut contents.lines, settings, &contents.line_data);
         });
         if sender.send(payload).is_err() {
             // The receiver has gone away, likely because the other thread hit an error.
@@ -187,7 +187,7 @@ fn read_write_loop<I: WriteableTmpFile>(
     separator: u8,
     buffer_size: usize,
     settings: &GlobalSettings,
-    receiver: Receiver<Chunk>,
+    receiver: &Receiver<Chunk>,
     sender: SyncSender<Chunk>,
 ) -> UResult<ReadResult<I>> {
     let mut file = files.next().unwrap()?;
diff --git a/src/uu/sort/src/main.rs b/src/uu/sort/src/main.rs
index ab463776d..f552ce37e 100644
--- a/src/uu/sort/src/main.rs
+++ b/src/uu/sort/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_sort);
+uucore::bin!(uu_sort);
diff --git a/src/uu/sort/src/merge.rs b/src/uu/sort/src/merge.rs
index 934d1c208..a7b4417e3 100644
--- a/src/uu/sort/src/merge.rs
+++ b/src/uu/sort/src/merge.rs
@@ -50,7 +50,7 @@ fn replace_output_file_in_input_files(
                         std::fs::copy(file_path, &copy_path)
                             .map_err(|error| SortError::OpenTmpFileFailed { error })?;
                         *file = copy_path.clone().into_os_string();
-                        copy = Some(copy_path)
+                        copy = Some(copy_path);
                     }
                 }
             }
@@ -166,7 +166,7 @@ fn merge_without_limit<M: MergeInput + 'static, F: Iterator<Item = UResult<M>>>(
         let settings = settings.clone();
         move || {
             reader(
-                request_receiver,
+                &request_receiver,
                 &mut reader_files,
                 &settings,
                 if settings.zero_terminated {
@@ -187,7 +187,7 @@ fn merge_without_limit<M: MergeInput + 'static, F: Iterator<Item = UResult<M>>>(
                 file_number,
                 line_idx: 0,
                 receiver,
-            })
+            });
         }
     }
 
@@ -210,7 +210,7 @@ struct ReaderFile<M: MergeInput> {
 
 /// The function running on the reader thread.
 fn reader(
-    recycled_receiver: Receiver<(usize, RecycledChunk)>,
+    recycled_receiver: &Receiver<(usize, RecycledChunk)>,
     files: &mut [Option<ReaderFile<impl MergeInput>>],
     settings: &GlobalSettings,
     separator: u8,
@@ -415,7 +415,7 @@ impl WriteableTmpFile for WriteablePlainTmpFile {
     type InnerWrite = BufWriter<File>;
 
     fn create((file, path): (File, PathBuf), _: Option<&str>) -> UResult<Self> {
-        Ok(WriteablePlainTmpFile {
+        Ok(Self {
             file: BufWriter::new(file),
             path,
         })
@@ -484,7 +484,7 @@ impl WriteableTmpFile for WriteableCompressedTmpFile {
                 code: err.raw_os_error().unwrap(),
             })?;
         let child_stdin = child.stdin.take().unwrap();
-        Ok(WriteableCompressedTmpFile {
+        Ok(Self {
             path,
             compress_prog: compress_prog.to_owned(),
             child,
diff --git a/src/uu/sort/src/numeric_str_cmp.rs b/src/uu/sort/src/numeric_str_cmp.rs
index d753c2d9d..d6855b267 100644
--- a/src/uu/sort/src/numeric_str_cmp.rs
+++ b/src/uu/sort/src/numeric_str_cmp.rs
@@ -52,7 +52,7 @@ impl NumInfo {
     /// an empty range (idx..idx) is returned so that idx is the char after the last zero.
     /// If the input is not a number (which has to be treated as zero), the returned empty range
     /// will be 0..0.
-    pub fn parse(num: &str, parse_settings: NumInfoParseSettings) -> (Self, Range<usize>) {
+    pub fn parse(num: &str, parse_settings: &NumInfoParseSettings) -> (Self, Range<usize>) {
         let mut exponent = -1;
         let mut had_decimal_pt = false;
         let mut had_digit = false;
@@ -80,17 +80,17 @@ impl NumInfo {
                 continue;
             }
 
-            if Self::is_invalid_char(char, &mut had_decimal_pt, &parse_settings) {
+            if Self::is_invalid_char(char, &mut had_decimal_pt, parse_settings) {
                 return if let Some(start) = start {
                     let has_si_unit = parse_settings.accept_si_units
                         && matches!(char, 'K' | 'k' | 'M' | 'G' | 'T' | 'P' | 'E' | 'Z' | 'Y');
                     (
-                        NumInfo { exponent, sign },
+                        Self { exponent, sign },
                         start..if has_si_unit { idx + 1 } else { idx },
                     )
                 } else {
                     (
-                        NumInfo {
+                        Self {
                             sign: Sign::Positive,
                             exponent: 0,
                         },
@@ -127,10 +127,10 @@ impl NumInfo {
             }
         }
         if let Some(start) = start {
-            (NumInfo { exponent, sign }, start..num.len())
+            (Self { exponent, sign }, start..num.len())
         } else {
             (
-                NumInfo {
+                Self {
                     sign: Sign::Positive,
                     exponent: 0,
                 },
@@ -270,7 +270,7 @@ mod tests {
     fn parses_exp() {
         let n = "1";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: 0,
@@ -281,7 +281,7 @@ mod tests {
         );
         let n = "100";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: 2,
@@ -294,7 +294,7 @@ mod tests {
         assert_eq!(
             NumInfo::parse(
                 n,
-                NumInfoParseSettings {
+                &NumInfoParseSettings {
                     thousands_separator: Some(','),
                     ..Default::default()
                 }
@@ -309,7 +309,7 @@ mod tests {
         );
         let n = "1,000";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: 0,
@@ -320,7 +320,7 @@ mod tests {
         );
         let n = "1000.00";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: 3,
@@ -334,7 +334,7 @@ mod tests {
     fn parses_negative_exp() {
         let n = "0.00005";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: -5,
@@ -345,7 +345,7 @@ mod tests {
         );
         let n = "00000.00005";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: -5,
@@ -360,7 +360,7 @@ mod tests {
     fn parses_sign() {
         let n = "5";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: 0,
@@ -371,7 +371,7 @@ mod tests {
         );
         let n = "-5";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: 0,
@@ -382,7 +382,7 @@ mod tests {
         );
         let n = "    -5";
         assert_eq!(
-            NumInfo::parse(n, Default::default()),
+            NumInfo::parse(n, &Default::default()),
             (
                 NumInfo {
                     exponent: 0,
@@ -394,8 +394,8 @@ mod tests {
     }
 
     fn test_helper(a: &str, b: &str, expected: Ordering) {
-        let (a_info, a_range) = NumInfo::parse(a, Default::default());
-        let (b_info, b_range) = NumInfo::parse(b, Default::default());
+        let (a_info, a_range) = NumInfo::parse(a, &Default::default());
+        let (b_info, b_range) = NumInfo::parse(b, &Default::default());
         let ordering = numeric_str_cmp(
             (&a[a_range.to_owned()], &a_info),
             (&b[b_range.to_owned()], &b_info),
@@ -470,7 +470,7 @@ mod tests {
     }
     #[test]
     fn single_minus() {
-        let info = NumInfo::parse("-", Default::default());
+        let info = NumInfo::parse("-", &Default::default());
         assert_eq!(
             info,
             (
@@ -486,7 +486,7 @@ mod tests {
     fn invalid_with_unit() {
         let info = NumInfo::parse(
             "-K",
-            NumInfoParseSettings {
+            &NumInfoParseSettings {
                 accept_si_units: true,
                 ..Default::default()
             },
diff --git a/src/uu/sort/src/sort.rs b/src/uu/sort/src/sort.rs
index ae1bcfa4c..a1aa92a2b 100644
--- a/src/uu/sort/src/sort.rs
+++ b/src/uu/sort/src/sort.rs
@@ -25,7 +25,7 @@ mod numeric_str_cmp;
 mod tmp_dir;
 
 use chunks::LineData;
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use custom_str_cmp::custom_str_cmp;
 use ext_sort::ext_sort;
 use fnv::FnvHasher;
@@ -33,6 +33,7 @@ use numeric_str_cmp::{human_numeric_str_cmp, numeric_str_cmp, NumInfo, NumInfoPa
 use rand::{thread_rng, Rng};
 use rayon::prelude::*;
 use std::cmp::Ordering;
+use std::convert::TryFrom;
 use std::env;
 use std::error::Error;
 use std::ffi::{OsStr, OsString};
@@ -49,11 +50,14 @@ use uucore::display::Quotable;
 use uucore::error::{set_exit_code, strip_errno, UError, UResult, USimpleError, UUsageError};
 use uucore::parse_size::{parse_size, ParseSizeError};
 use uucore::version_cmp::version_cmp;
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 use crate::tmp_dir::TmpDirWrapper;
 
-const ABOUT: &str = "Display sorted concatenation of all FILE(s).";
+const ABOUT: &str = "\
+    Display sorted concatenation of all FILE(s). \
+    With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
 const LONG_HELP_KEYS: &str = "The key format is FIELD[.CHAR][OPTIONS][,FIELD[.CHAR]][OPTIONS].
 
@@ -94,6 +98,7 @@ mod options {
         pub const DIAGNOSE_FIRST: &str = "diagnose-first";
     }
 
+    pub const HELP: &str = "help";
     pub const DICTIONARY_ORDER: &str = "dictionary-order";
     pub const MERGE: &str = "merge";
     pub const DEBUG: &str = "debug";
@@ -176,7 +181,7 @@ impl UError for SortError {
 impl Display for SortError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            SortError::Disorder {
+            Self::Disorder {
                 file,
                 line_number,
                 line,
@@ -194,7 +199,7 @@ impl Display for SortError {
                     Ok(())
                 }
             }
-            SortError::OpenFailed { path, error } => {
+            Self::OpenFailed { path, error } => {
                 write!(
                     f,
                     "open failed: {}: {}",
@@ -202,10 +207,10 @@ impl Display for SortError {
                     strip_errno(error)
                 )
             }
-            SortError::ParseKeyError { key, msg } => {
+            Self::ParseKeyError { key, msg } => {
                 write!(f, "failed to parse key {}: {}", key.quote(), msg)
             }
-            SortError::ReadFailed { path, error } => {
+            Self::ReadFailed { path, error } => {
                 write!(
                     f,
                     "cannot read: {}: {}",
@@ -213,17 +218,17 @@ impl Display for SortError {
                     strip_errno(error)
                 )
             }
-            SortError::OpenTmpFileFailed { error } => {
+            Self::OpenTmpFileFailed { error } => {
                 write!(f, "failed to open temporary file: {}", strip_errno(error))
             }
-            SortError::CompressProgExecutionFailed { code } => {
+            Self::CompressProgExecutionFailed { code } => {
                 write!(f, "couldn't execute compress program: errno {}", code)
             }
-            SortError::CompressProgTerminatedAbnormally { prog } => {
+            Self::CompressProgTerminatedAbnormally { prog } => {
                 write!(f, "{} terminated abnormally", prog.quote())
             }
-            SortError::TmpDirCreationFailed => write!(f, "could not create temporary directory"),
-            SortError::Uft8Error { error } => write!(f, "{}", error),
+            Self::TmpDirCreationFailed => write!(f, "could not create temporary directory"),
+            Self::Uft8Error { error } => write!(f, "{}", error),
         }
     }
 }
@@ -242,13 +247,13 @@ enum SortMode {
 impl SortMode {
     fn get_short_name(&self) -> Option<char> {
         match self {
-            SortMode::Numeric => Some('n'),
-            SortMode::HumanNumeric => Some('h'),
-            SortMode::GeneralNumeric => Some('g'),
-            SortMode::Month => Some('M'),
-            SortMode::Version => Some('V'),
-            SortMode::Random => Some('R'),
-            SortMode::Default => None,
+            Self::Numeric => Some('n'),
+            Self::HumanNumeric => Some('h'),
+            Self::GeneralNumeric => Some('g'),
+            Self::Month => Some('M'),
+            Self::Version => Some('V'),
+            Self::Random => Some('R'),
+            Self::Default => None,
         }
     }
 }
@@ -323,7 +328,7 @@ pub struct GlobalSettings {
 
 /// Data needed for sorting. Should be computed once before starting to sort
 /// by calling `GlobalSettings::init_precomputed`.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 struct Precomputed {
     needs_tokens: bool,
     num_infos_per_line: usize,
@@ -351,7 +356,13 @@ impl GlobalSettings {
             } else if size_string.ends_with('b') {
                 size_string.pop();
             }
-            parse_size(&size_string)
+            let size = parse_size(&size_string)?;
+            usize::try_from(size).map_err(|_| {
+                ParseSizeError::SizeTooBig(format!(
+                    "Buffer size {} does not fit in address space",
+                    size
+                ))
+            })
         } else {
             Err(ParseSizeError::ParseFailure("invalid suffix".to_string()))
         }
@@ -378,8 +389,8 @@ impl GlobalSettings {
 }
 
 impl Default for GlobalSettings {
-    fn default() -> GlobalSettings {
-        GlobalSettings {
+    fn default() -> Self {
+        Self {
             mode: SortMode::Default,
             debug: false,
             ignore_leading_blanks: false,
@@ -400,12 +411,7 @@ impl Default for GlobalSettings {
             buffer_size: DEFAULT_BUF_SIZE,
             compress_prog: None,
             merge_batch_size: 32,
-            precomputed: Precomputed {
-                num_infos_per_line: 0,
-                floats_per_line: 0,
-                selections_per_line: 0,
-                needs_tokens: false,
-            },
+            precomputed: Precomputed::default(),
         }
     }
 }
@@ -535,7 +541,7 @@ impl<'a> Line<'a> {
                 }
                 Selection::Str(str) => {
                     if selector.needs_selection {
-                        line_data.selections.push(str)
+                        line_data.selections.push(str);
                     }
                 }
             }
@@ -571,14 +577,14 @@ impl<'a> Line<'a> {
 
         let mut fields = vec![];
         tokenize(self.line, settings.separator, &mut fields);
-        for selector in settings.selectors.iter() {
+        for selector in &settings.selectors {
             let mut selection = selector.get_range(self.line, Some(&fields));
             match selector.settings.mode {
                 SortMode::Numeric | SortMode::HumanNumeric => {
                     // find out which range is used for numeric comparisons
                     let (_, num_range) = NumInfo::parse(
                         &self.line[selection.clone()],
-                        NumInfoParseSettings {
+                        &NumInfoParseSettings {
                             accept_si_units: selector.settings.mode == SortMode::HumanNumeric,
                             ..Default::default()
                         },
@@ -701,9 +707,9 @@ impl<'a> Line<'a> {
 fn tokenize(line: &str, separator: Option<char>, token_buffer: &mut Vec<Field>) {
     assert!(token_buffer.is_empty());
     if let Some(separator) = separator {
-        tokenize_with_separator(line, separator, token_buffer)
+        tokenize_with_separator(line, separator, token_buffer);
     } else {
-        tokenize_default(line, token_buffer)
+        tokenize_default(line, token_buffer);
     }
 }
 
@@ -784,7 +790,7 @@ impl KeyPosition {
 
 impl Default for KeyPosition {
     fn default() -> Self {
-        KeyPosition {
+        Self {
             field: 1,
             char: 1,
             ignore_blanks: false,
@@ -927,7 +933,7 @@ impl FieldSelector {
             // Parse NumInfo for this number.
             let (info, num_range) = NumInfo::parse(
                 range,
-                NumInfoParseSettings {
+                &NumInfoParseSettings {
                     accept_si_units: self.settings.mode == SortMode::HumanNumeric,
                     ..Default::default()
                 },
@@ -1035,19 +1041,9 @@ impl FieldSelector {
     }
 }
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [FILE]...
-Write the sorted concatenation of all FILE(s) to standard output.
-Mandatory arguments for long options are mandatory for short options too.
-With no FILE, or when FILE is -, read standard input.",
-        uucore::execution_phrase()
-    )
-}
-
 /// Creates an `Arg` that conflicts with all other sort modes.
-fn make_sort_mode_arg<'a, 'b>(mode: &'a str, short: &'b str, help: &'b str) -> Arg<'a, 'b> {
-    let mut arg = Arg::with_name(mode).short(short).long(mode).help(help);
+fn make_sort_mode_arg<'a>(mode: &'a str, short: char, help: &'a str) -> Arg<'a> {
+    let mut arg = Arg::new(mode).short(short).long(mode).help(help);
     for possible_mode in &options::modes::ALL_SORT_MODES {
         if *possible_mode != mode {
             arg = arg.conflicts_with(possible_mode);
@@ -1056,15 +1052,14 @@ fn make_sort_mode_arg<'a, 'b>(mode: &'a str, short: &'b str, help: &'b str) -> A
     arg
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
-    let usage = usage();
     let mut settings: GlobalSettings = Default::default();
 
-    let matches = match uu_app().usage(&usage[..]).get_matches_from_safe(args) {
+    let matches = match uu_app().try_get_matches_from(args) {
         Ok(t) => t,
         Err(e) => {
             // not all clap "Errors" are because of a failure to parse arguments.
@@ -1072,11 +1067,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             // nor return with a non-zero exit code in this case (we should print to stdout and return 0).
             // This logic is similar to the code in clap, but we return 2 as the exit code in case of real failure
             // (clap returns 1).
+            e.print().unwrap();
             if e.use_stderr() {
-                eprintln!("{}", e.message);
                 set_exit_code(2);
-            } else {
-                println!("{}", e.message);
             }
             return Ok(());
         }
@@ -1155,7 +1148,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             .value_of(options::BUF_SIZE)
             .map_or(Ok(DEFAULT_BUF_SIZE), |s| {
                 GlobalSettings::parse_byte_count(s).map_err(|e| {
-                    USimpleError::new(2, format_error_message(e, s, options::BUF_SIZE))
+                    USimpleError::new(2, format_error_message(&e, s, options::BUF_SIZE))
                 })
             })?;
 
@@ -1209,11 +1202,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     }
 
-    if let Some(arg) = matches.args.get(options::SEPARATOR) {
-        let mut separator = arg.vals[0].to_str().ok_or_else(|| {
+    if let Some(arg) = matches.value_of_os(options::SEPARATOR) {
+        let mut separator = arg.to_str().ok_or_else(|| {
             UUsageError::new(
                 2,
-                format!("separator is not valid unicode: {}", arg.vals[0].quote()),
+                format!("separator is not valid unicode: {}", arg.quote()),
             )
         })?;
         if separator == "\\0" {
@@ -1231,7 +1224,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 ),
             ));
         }
-        settings.separator = Some(separator.chars().next().unwrap())
+        settings.separator = Some(separator.chars().next().unwrap());
     }
 
     if let Some(values) = matches.values_of(options::KEY) {
@@ -1276,12 +1269,19 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     exec(&mut files, &settings, output, &mut tmp_dir)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::modes::SORT)
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information."),
+        )
+        .arg(
+            Arg::new(options::modes::SORT)
                 .long(options::modes::SORT)
                 .takes_value(true)
                 .possible_values(&[
@@ -1296,37 +1296,37 @@ pub fn uu_app() -> App<'static, 'static> {
         )
         .arg(make_sort_mode_arg(
             options::modes::HUMAN_NUMERIC,
-            "h",
+            'h',
             "compare according to human readable sizes, eg 1M > 100k",
         ))
         .arg(make_sort_mode_arg(
             options::modes::MONTH,
-            "M",
+            'M',
             "compare according to month name abbreviation",
         ))
         .arg(make_sort_mode_arg(
             options::modes::NUMERIC,
-            "n",
+            'n',
             "compare according to string numerical value",
         ))
         .arg(make_sort_mode_arg(
             options::modes::GENERAL_NUMERIC,
-            "g",
+            'g',
             "compare according to string general numerical value",
         ))
         .arg(make_sort_mode_arg(
             options::modes::VERSION,
-            "V",
+            'V',
             "Sort by SemVer version number, eg 1.12.2 > 1.1.2",
         ))
         .arg(make_sort_mode_arg(
             options::modes::RANDOM,
-            "R",
+            'R',
             "shuffle in random order",
         ))
         .arg(
-            Arg::with_name(options::DICTIONARY_ORDER)
-                .short("d")
+            Arg::new(options::DICTIONARY_ORDER)
+                .short('d')
                 .long(options::DICTIONARY_ORDER)
                 .help("consider only blanks and alphanumeric characters")
                 .conflicts_with_all(&[
@@ -1337,14 +1337,14 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::MERGE)
-                .short("m")
+            Arg::new(options::MERGE)
+                .short('m')
                 .long(options::MERGE)
                 .help("merge already sorted files; do not sort"),
         )
         .arg(
-            Arg::with_name(options::check::CHECK)
-                .short("c")
+            Arg::new(options::check::CHECK)
+                .short('c')
                 .long(options::check::CHECK)
                 .takes_value(true)
                 .require_equals(true)
@@ -1358,24 +1358,24 @@ pub fn uu_app() -> App<'static, 'static> {
                 .help("check for sorted input; do not sort"),
         )
         .arg(
-            Arg::with_name(options::check::CHECK_SILENT)
-                .short("C")
+            Arg::new(options::check::CHECK_SILENT)
+                .short('C')
                 .long(options::check::CHECK_SILENT)
                 .conflicts_with(options::OUTPUT)
                 .help(
-                    "exit successfully if the given file is already sorted,\
+                    "exit successfully if the given file is already sorted, \
                 and exit with status 1 otherwise.",
                 ),
         )
         .arg(
-            Arg::with_name(options::IGNORE_CASE)
-                .short("f")
+            Arg::new(options::IGNORE_CASE)
+                .short('f')
                 .long(options::IGNORE_CASE)
                 .help("fold lower case to upper case characters"),
         )
         .arg(
-            Arg::with_name(options::IGNORE_NONPRINTING)
-                .short("i")
+            Arg::new(options::IGNORE_NONPRINTING)
+                .short('i')
                 .long(options::IGNORE_NONPRINTING)
                 .help("ignore nonprinting characters")
                 .conflicts_with_all(&[
@@ -1386,113 +1386,116 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::IGNORE_LEADING_BLANKS)
-                .short("b")
+            Arg::new(options::IGNORE_LEADING_BLANKS)
+                .short('b')
                 .long(options::IGNORE_LEADING_BLANKS)
                 .help("ignore leading blanks when finding sort keys in each line"),
         )
         .arg(
-            Arg::with_name(options::OUTPUT)
-                .short("o")
+            Arg::new(options::OUTPUT)
+                .short('o')
                 .long(options::OUTPUT)
                 .help("write output to FILENAME instead of stdout")
                 .takes_value(true)
                 .value_name("FILENAME"),
         )
         .arg(
-            Arg::with_name(options::REVERSE)
-                .short("r")
+            Arg::new(options::REVERSE)
+                .short('r')
                 .long(options::REVERSE)
                 .help("reverse the output"),
         )
         .arg(
-            Arg::with_name(options::STABLE)
-                .short("s")
+            Arg::new(options::STABLE)
+                .short('s')
                 .long(options::STABLE)
                 .help("stabilize sort by disabling last-resort comparison"),
         )
         .arg(
-            Arg::with_name(options::UNIQUE)
-                .short("u")
+            Arg::new(options::UNIQUE)
+                .short('u')
                 .long(options::UNIQUE)
                 .help("output only the first of an equal run"),
         )
         .arg(
-            Arg::with_name(options::KEY)
-                .short("k")
+            Arg::new(options::KEY)
+                .short('k')
                 .long(options::KEY)
                 .help("sort by a key")
                 .long_help(LONG_HELP_KEYS)
-                .multiple(true)
+                .multiple_occurrences(true)
                 .number_of_values(1)
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::SEPARATOR)
-                .short("t")
+            Arg::new(options::SEPARATOR)
+                .short('t')
                 .long(options::SEPARATOR)
                 .help("custom separator for -k")
-                .takes_value(true),
+                .takes_value(true)
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::ZERO_TERMINATED)
-                .short("z")
+            Arg::new(options::ZERO_TERMINATED)
+                .short('z')
                 .long(options::ZERO_TERMINATED)
                 .help("line delimiter is NUL, not newline"),
         )
         .arg(
-            Arg::with_name(options::PARALLEL)
+            Arg::new(options::PARALLEL)
                 .long(options::PARALLEL)
                 .help("change the number of threads running concurrently to NUM_THREADS")
                 .takes_value(true)
                 .value_name("NUM_THREADS"),
         )
         .arg(
-            Arg::with_name(options::BUF_SIZE)
-                .short("S")
+            Arg::new(options::BUF_SIZE)
+                .short('S')
                 .long(options::BUF_SIZE)
                 .help("sets the maximum SIZE of each segment in number of sorted items")
                 .takes_value(true)
                 .value_name("SIZE"),
         )
         .arg(
-            Arg::with_name(options::TMP_DIR)
-                .short("T")
+            Arg::new(options::TMP_DIR)
+                .short('T')
                 .long(options::TMP_DIR)
                 .help("use DIR for temporaries, not $TMPDIR or /tmp")
                 .takes_value(true)
                 .value_name("DIR"),
         )
         .arg(
-            Arg::with_name(options::COMPRESS_PROG)
+            Arg::new(options::COMPRESS_PROG)
                 .long(options::COMPRESS_PROG)
                 .help("compress temporary files with PROG, decompress with PROG -d")
                 .long_help("PROG has to take input from stdin and output to stdout")
                 .value_name("PROG"),
         )
         .arg(
-            Arg::with_name(options::BATCH_SIZE)
+            Arg::new(options::BATCH_SIZE)
                 .long(options::BATCH_SIZE)
                 .help("Merge at most N_MERGE inputs at once.")
                 .value_name("N_MERGE"),
         )
         .arg(
-            Arg::with_name(options::FILES0_FROM)
+            Arg::new(options::FILES0_FROM)
                 .long(options::FILES0_FROM)
                 .help("read input from the files specified by NUL-terminated NUL_FILES")
                 .takes_value(true)
                 .value_name("NUL_FILES")
-                .multiple(true),
+                .multiple_occurrences(true)
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::DEBUG)
+            Arg::new(options::DEBUG)
                 .long(options::DEBUG)
                 .help("underline the parts of the line that are actually used for sorting"),
         )
         .arg(
-            Arg::with_name(options::FILES)
-                .multiple(true)
-                .takes_value(true),
+            Arg::new(options::FILES)
+                .multiple_occurrences(true)
+                .takes_value(true)
+                .allow_invalid_utf8(true),
         )
 }
 
@@ -1519,9 +1522,9 @@ fn exec(
 
 fn sort_by<'a>(unsorted: &mut Vec<Line<'a>>, settings: &GlobalSettings, line_data: &LineData<'a>) {
     if settings.stable || settings.unique {
-        unsorted.par_sort_by(|a, b| compare_by(a, b, settings, line_data, line_data))
+        unsorted.par_sort_by(|a, b| compare_by(a, b, settings, line_data, line_data));
     } else {
-        unsorted.par_sort_unstable_by(|a, b| compare_by(a, b, settings, line_data, line_data))
+        unsorted.par_sort_unstable_by(|a, b| compare_by(a, b, settings, line_data, line_data));
     }
 }
 
@@ -1824,7 +1827,7 @@ fn open(path: impl AsRef<OsStr>) -> UResult<Box<dyn Read + Send>> {
     }
 }
 
-fn format_error_message(error: ParseSizeError, s: &str, option: &str) -> String {
+fn format_error_message(error: &ParseSizeError, s: &str, option: &str) -> String {
     // NOTE:
     // GNU's sort echos affected flag, -S or --buffer-size, depending user's selection
     // GNU's sort does distinguish between "invalid (suffix in) argument"
diff --git a/src/uu/split/BENCHMARKING.md b/src/uu/split/BENCHMARKING.md
new file mode 100644
index 000000000..9c8d5d17c
--- /dev/null
+++ b/src/uu/split/BENCHMARKING.md
@@ -0,0 +1,47 @@
+<!-- spell-checker:ignore testfile -->
+
+# Benchmarking to measure performance
+
+To compare the performance of the `uutils` version of `split` with the
+GNU version of `split`, you can use a benchmarking tool like
+[hyperfine][0]. On Ubuntu 18.04 or later, you can install `hyperfine` by
+running
+
+    sudo apt-get install hyperfine
+
+Next, build the `split` binary under the release profile:
+
+    cargo build --release -p uu_split
+
+Now, get a text file to test `split` on. The `split` program has three
+main modes of operation: chunk by lines, chunk by bytes, and chunk by
+lines with a byte limit. You may want to test the performance of `split`
+with various shapes and sizes of input files and under various modes of
+operation. For example, to test chunking by bytes on a large input file,
+you can create a file named `testfile.txt` containing one million null
+bytes like this:
+
+    printf "%0.s\0" {1..1000000} > testfile.txt
+
+For another example, to test chunking by bytes on a large real-world
+input file, you could download a [database dump of Wikidata][1] or some
+related files that the Wikimedia project provides. For example, [this
+file][2] contains about 130 million lines.
+
+Finally, you can compare the performance of the two versions of `split`
+by running, for example,
+
+    cd /tmp && hyperfine \
+        --prepare 'rm x* || true' \
+	"split -b 1000 testfile.txt" \
+	"target/release/split -b 1000 testfile.txt"
+
+Since `split` creates a lot of files on the filesystem, I recommend
+changing to the `/tmp` directory before running the benchmark. The
+`--prepare` argument to `hyperfine` runs a specified command before each
+timing run. We specify `rm x* || true` so that the output files from the
+previous run of `split` are removed before each run begins.
+
+[0]: https://github.com/sharkdp/hyperfine
+[1]: https://www.wikidata.org/wiki/Wikidata:Database_download
+[2]: https://dumps.wikimedia.org/wikidatawiki/20211001/wikidatawiki-20211001-pages-logging.xml.gz
diff --git a/src/uu/split/Cargo.toml b/src/uu/split/Cargo.toml
index 44d0350b2..316774621 100644
--- a/src/uu/split/Cargo.toml
+++ b/src/uu/split/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_split"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "split ~ (uutils) split input into output files"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/split"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/split"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,10 @@ edition = "2018"
 path = "src/split.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+memchr = "2"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "split"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/split/LICENSE b/src/uu/split/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/split/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/split/src/filenames.rs b/src/uu/split/src/filenames.rs
new file mode 100644
index 000000000..6f68caeb4
--- /dev/null
+++ b/src/uu/split/src/filenames.rs
@@ -0,0 +1,211 @@
+//  * 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 zaaa zaab
+//! Compute filenames from a given index.
+//!
+//! The [`FilenameIterator`] yields filenames for use with ``split``.
+//!
+//! # Examples
+//!
+//! Create filenames of the form `chunk_??.txt`:
+//!
+//! ```rust,ignore
+//! use crate::filenames::FilenameIterator;
+//! use crate::filenames::SuffixType;
+//!
+//! let prefix = "chunk_".to_string();
+//! let suffix = ".txt".to_string();
+//! let width = 2;
+//! let suffix_type = SuffixType::Alphabetic;
+//! let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+//!
+//! assert_eq!(it.next().unwrap(), "chunk_aa.txt");
+//! assert_eq!(it.next().unwrap(), "chunk_ab.txt");
+//! assert_eq!(it.next().unwrap(), "chunk_ac.txt");
+//! ```
+use crate::number::DynamicWidthNumber;
+use crate::number::FixedWidthNumber;
+use crate::number::Number;
+
+/// The format to use for suffixes in the filename for each output chunk.
+#[derive(Clone, Copy)]
+pub enum SuffixType {
+    /// Lowercase ASCII alphabetic characters.
+    Alphabetic,
+
+    /// Decimal numbers.
+    Decimal,
+
+    /// Hexadecimal numbers.
+    Hexadecimal,
+}
+
+impl SuffixType {
+    /// The radix to use when representing the suffix string as digits.
+    pub fn radix(&self) -> u8 {
+        match self {
+            Self::Alphabetic => 26,
+            Self::Decimal => 10,
+            Self::Hexadecimal => 16,
+        }
+    }
+}
+
+/// Compute filenames from a given index.
+///
+/// This iterator yields filenames for use with ``split``.
+///
+/// The `prefix` is prepended to each filename and the
+/// `additional_suffix1 is appended to each filename.
+///
+/// If `suffix_length` is 0, then the variable portion of the filename
+/// that identifies the current chunk will have a dynamically
+/// increasing width. If `suffix_length` is greater than zero, then
+/// the variable portion of the filename will always be exactly that
+/// width in characters. In that case, after the iterator yields each
+/// string of that width, the iterator is exhausted.
+///
+/// Finally, `suffix_type` controls which type of suffix to produce,
+/// alphabetic or numeric.
+///
+/// # Examples
+///
+/// Create filenames of the form `chunk_??.txt`, where the `?`
+/// characters are lowercase ASCII alphabetic characters:
+///
+/// ```rust,ignore
+/// use crate::filenames::FilenameIterator;
+/// use crate::filenames::SuffixType;
+///
+/// let prefix = "chunk_".to_string();
+/// let suffix = ".txt".to_string();
+/// let width = 2;
+/// let suffix_type = SuffixType::Alphabetic;
+/// let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+///
+/// assert_eq!(it.next().unwrap(), "chunk_aa.txt");
+/// assert_eq!(it.next().unwrap(), "chunk_ab.txt");
+/// assert_eq!(it.next().unwrap(), "chunk_ac.txt");
+/// ```
+///
+/// For decimal numeric filenames, use `SuffixType::Decimal`:
+///
+/// ```rust,ignore
+/// use crate::filenames::FilenameIterator;
+/// use crate::filenames::SuffixType;
+///
+/// let prefix = "chunk_".to_string();
+/// let suffix = ".txt".to_string();
+/// let width = 2;
+/// let suffix_type = SuffixType::Decimal;
+/// let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+///
+/// assert_eq!(it.next().unwrap(), "chunk_00.txt");
+/// assert_eq!(it.next().unwrap(), "chunk_01.txt");
+/// assert_eq!(it.next().unwrap(), "chunk_02.txt");
+/// ```
+pub struct FilenameIterator<'a> {
+    additional_suffix: &'a str,
+    prefix: &'a str,
+    number: Number,
+    first_iteration: bool,
+}
+
+impl<'a> FilenameIterator<'a> {
+    pub fn new(
+        prefix: &'a str,
+        additional_suffix: &'a str,
+        suffix_length: usize,
+        suffix_type: SuffixType,
+    ) -> FilenameIterator<'a> {
+        let radix = suffix_type.radix();
+        let number = if suffix_length == 0 {
+            Number::DynamicWidth(DynamicWidthNumber::new(radix))
+        } else {
+            Number::FixedWidth(FixedWidthNumber::new(radix, suffix_length))
+        };
+        FilenameIterator {
+            prefix,
+            additional_suffix,
+            number,
+            first_iteration: true,
+        }
+    }
+}
+
+impl<'a> Iterator for FilenameIterator<'a> {
+    type Item = String;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.first_iteration {
+            self.first_iteration = false;
+        } else {
+            self.number.increment().ok()?;
+        }
+        // The first and third parts are just taken directly from the
+        // struct parameters unchanged.
+        Some(format!(
+            "{}{}{}",
+            self.prefix, self.number, self.additional_suffix
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::filenames::FilenameIterator;
+    use crate::filenames::SuffixType;
+
+    #[test]
+    fn test_filename_iterator_alphabetic_fixed_width() {
+        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Alphabetic);
+        assert_eq!(it.next().unwrap(), "chunk_aa.txt");
+        assert_eq!(it.next().unwrap(), "chunk_ab.txt");
+        assert_eq!(it.next().unwrap(), "chunk_ac.txt");
+
+        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Alphabetic);
+        assert_eq!(it.nth(26 * 26 - 1).unwrap(), "chunk_zz.txt");
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn test_filename_iterator_numeric_fixed_width() {
+        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Decimal);
+        assert_eq!(it.next().unwrap(), "chunk_00.txt");
+        assert_eq!(it.next().unwrap(), "chunk_01.txt");
+        assert_eq!(it.next().unwrap(), "chunk_02.txt");
+
+        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Decimal);
+        assert_eq!(it.nth(10 * 10 - 1).unwrap(), "chunk_99.txt");
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn test_filename_iterator_alphabetic_dynamic_width() {
+        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Alphabetic);
+        assert_eq!(it.next().unwrap(), "chunk_aa.txt");
+        assert_eq!(it.next().unwrap(), "chunk_ab.txt");
+        assert_eq!(it.next().unwrap(), "chunk_ac.txt");
+
+        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Alphabetic);
+        assert_eq!(it.nth(26 * 25 - 1).unwrap(), "chunk_yz.txt");
+        assert_eq!(it.next().unwrap(), "chunk_zaaa.txt");
+        assert_eq!(it.next().unwrap(), "chunk_zaab.txt");
+    }
+
+    #[test]
+    fn test_filename_iterator_numeric_dynamic_width() {
+        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal);
+        assert_eq!(it.next().unwrap(), "chunk_00.txt");
+        assert_eq!(it.next().unwrap(), "chunk_01.txt");
+        assert_eq!(it.next().unwrap(), "chunk_02.txt");
+
+        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal);
+        assert_eq!(it.nth(10 * 9 - 1).unwrap(), "chunk_89.txt");
+        assert_eq!(it.next().unwrap(), "chunk_9000.txt");
+        assert_eq!(it.next().unwrap(), "chunk_9001.txt");
+    }
+}
diff --git a/src/uu/split/src/main.rs b/src/uu/split/src/main.rs
index 87f15f529..0ef3e026f 100644
--- a/src/uu/split/src/main.rs
+++ b/src/uu/split/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_split);
+uucore::bin!(uu_split);
diff --git a/src/uu/split/src/number.rs b/src/uu/split/src/number.rs
new file mode 100644
index 000000000..c7557271d
--- /dev/null
+++ b/src/uu/split/src/number.rs
@@ -0,0 +1,586 @@
+//  * 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 zaaa zaab
+//! A number in arbitrary radix expressed in a positional notation.
+//!
+//! Use the [`Number`] enum to represent an arbitrary number in an
+//! arbitrary radix. A number can be incremented and can be
+//! displayed. See the [`Number`] documentation for more information.
+//!
+//! See the Wikipedia articles on [radix] and [positional notation]
+//! for more background information on those topics.
+//!
+//! [radix]: https://en.wikipedia.org/wiki/Radix
+//! [positional notation]: https://en.wikipedia.org/wiki/Positional_notation
+use std::error::Error;
+use std::fmt::{self, Display, Formatter};
+
+/// An overflow due to incrementing a number beyond its representable limit.
+#[derive(Debug)]
+pub struct Overflow;
+
+impl fmt::Display for Overflow {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Overflow")
+    }
+}
+
+impl Error for Overflow {}
+
+/// A number in arbitrary radix expressed in a positional notation.
+///
+/// Use the [`Number`] enum to represent an arbitrary number in an
+/// arbitrary radix. A number can be incremented with
+/// [`Number::increment`].  The [`FixedWidthNumber`] overflows when
+/// attempting to increment it beyond the maximum number that can be
+/// represented in the specified width. The [`DynamicWidthNumber`]
+/// follows a non-standard incrementing procedure that is used
+/// specifically for the `split` program. See the
+/// [`DynamicWidthNumber`] documentation for more information.
+///
+/// Numbers of radix
+///
+/// * 10 are displayable and rendered as decimal numbers (for example,
+///   "00" or "917"),
+/// * 16 are displayable and rendered as hexadecimal numbers (for example,
+///   "00" or "e7f"),
+/// * 26 are displayable and rendered as lowercase ASCII alphabetic
+///   characters (for example, "aa" or "zax").
+///
+/// Numbers of other radices cannot be displayed. The display of a
+/// [`DynamicWidthNumber`] includes a prefix whose length depends on
+/// the width of the number. See the [`DynamicWidthNumber`]
+/// documentation for more information.
+///
+/// The digits of a number are accessible via the [`Number::digits`]
+/// method. The digits are represented as a [`Vec<u8>`] with the most
+/// significant digit on the left and the least significant digit on
+/// the right. Each digit is a nonnegative integer less than the
+/// radix. For example, if the radix is 3, then `vec![1, 0, 2]`
+/// represents the decimal number 11:
+///
+/// ```ignore
+/// 1 * 3^2 + 0 * 3^1 + 2 * 3^0 = 9 + 0 + 2 = 11
+/// ```
+///
+/// For the [`DynamicWidthNumber`], the digits are not unique in the
+/// sense that repeatedly incrementing the number will eventually
+/// yield `vec![0, 0]`, `vec![0, 0, 0], `vec![0, 0, 0, 0]`, etc.
+/// That's okay because each of these numbers will be displayed
+/// differently and we only intend to use these numbers for display
+/// purposes and not for mathematical purposes.
+#[derive(Clone)]
+pub enum Number {
+    /// A fixed-width representation of a number.
+    FixedWidth(FixedWidthNumber),
+
+    /// A representation of a number with a dynamically growing width.
+    DynamicWidth(DynamicWidthNumber),
+}
+
+impl Number {
+    /// The digits of this number in decreasing order of significance.
+    ///
+    /// The digits are represented as a [`Vec<u8>`] with the most
+    /// significant digit on the left and the least significant digit
+    /// on the right. Each digit is a nonnegative integer less than
+    /// the radix. For example, if the radix is 3, then `vec![1, 0,
+    /// 2]` represents the decimal number 11:
+    ///
+    /// ```ignore
+    /// 1 * 3^2 + 0 * 3^1 + 2 * 3^0 = 9 + 0 + 2 = 11
+    /// ```
+    ///
+    /// For the [`DynamicWidthNumber`], the digits are not unique in the
+    /// sense that repeatedly incrementing the number will eventually
+    /// yield `vec![0, 0]`, `vec![0, 0, 0], `vec![0, 0, 0, 0]`, etc.
+    /// That's okay because each of these numbers will be displayed
+    /// differently and we only intend to use these numbers for display
+    /// purposes and not for mathematical purposes.
+    #[allow(dead_code)]
+    fn digits(&self) -> &Vec<u8> {
+        match self {
+            Self::FixedWidth(number) => &number.digits,
+            Self::DynamicWidth(number) => &number.digits,
+        }
+    }
+
+    /// Increment this number to its successor.
+    ///
+    /// If incrementing this number would result in an overflow beyond
+    /// the maximum representable number, then return
+    /// [`Err(Overflow)`]. The [`FixedWidthNumber`] overflows, but
+    /// [`DynamicWidthNumber`] does not.
+    ///
+    /// The [`DynamicWidthNumber`] follows a non-standard incrementing
+    /// procedure that is used specifically for the `split` program.
+    /// See the [`DynamicWidthNumber`] documentation for more
+    /// information.
+    ///
+    /// # Errors
+    ///
+    /// This method returns [`Err(Overflow)`] when attempting to
+    /// increment beyond the largest representable number.
+    ///
+    /// # Examples
+    ///
+    /// Overflowing:
+    ///
+    /// ```rust,ignore
+    ///
+    /// use crate::number::FixedWidthNumber;
+    /// use crate::number::Number;
+    /// use crate::number::Overflow;
+    ///
+    /// // Radix 3, width of 1 digit.
+    /// let mut number = Number::FixedWidth(FixedWidthNumber::new(3, 1));
+    /// number.increment().unwrap();  // from 0 to 1
+    /// number.increment().unwrap();  // from 1 to 2
+    /// assert!(number.increment().is_err());
+    /// ```
+    pub fn increment(&mut self) -> Result<(), Overflow> {
+        match self {
+            Self::FixedWidth(number) => number.increment(),
+            Self::DynamicWidth(number) => number.increment(),
+        }
+    }
+}
+
+impl Display for Number {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::FixedWidth(number) => number.fmt(f),
+            Self::DynamicWidth(number) => number.fmt(f),
+        }
+    }
+}
+
+/// A positional notation representation of a fixed-width number.
+///
+/// The digits are represented as a [`Vec<u8>`] with the most
+/// significant digit on the left and the least significant digit on
+/// the right. Each digit is a nonnegative integer less than the
+/// radix.
+///
+/// # Incrementing
+///
+/// This number starts at `vec![0; width]`, representing the number 0
+/// width the specified number of digits. Incrementing this number
+/// with [`Number::increment`] causes it to increase its value by 1 in
+/// the usual sense. If the digits are `vec![radix - 1; width]`, then
+/// an overflow would occur and the [`Number::increment`] method
+/// returns an error.
+///
+/// # Displaying
+///
+/// This number is only displayable if `radix` is 10, 26, or 26. If
+/// `radix` is 10 or 16, then the digits are concatenated and
+/// displayed as a fixed-width decimal or hexadecimal number,
+/// respectively. If `radix` is 26, then each digit is translated to
+/// the corresponding lowercase ASCII alphabetic character (that is,
+/// 'a', 'b', 'c', etc.) and concatenated.
+#[derive(Clone)]
+pub struct FixedWidthNumber {
+    radix: u8,
+    digits: Vec<u8>,
+}
+
+impl FixedWidthNumber {
+    /// Instantiate a number of the given radix and width.
+    pub fn new(radix: u8, width: usize) -> Self {
+        Self {
+            radix,
+            digits: vec![0; width],
+        }
+    }
+
+    /// Increment this number.
+    ///
+    /// This method adds one to this number. If incrementing this
+    /// number would require more digits than are available with the
+    /// specified width, then this method returns [`Err(Overflow)`].
+    fn increment(&mut self) -> Result<(), Overflow> {
+        for i in (0..self.digits.len()).rev() {
+            // Increment the current digit.
+            self.digits[i] += 1;
+
+            // If the digit overflows, then set it to 0 and continue
+            // to the next iteration to increment the next most
+            // significant digit. Otherwise, terminate the loop, since
+            // there will be no further changes to any higher order
+            // digits.
+            if self.digits[i] == self.radix {
+                self.digits[i] = 0;
+            } else {
+                break;
+            }
+        }
+
+        // Return an error on overflow, which is signified by all zeros.
+        if self.digits == vec![0; self.digits.len()] {
+            Err(Overflow)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl Display for FixedWidthNumber {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self.radix {
+            10 => {
+                let digits: String = self.digits.iter().map(|d| (b'0' + d) as char).collect();
+                write!(f, "{}", digits)
+            }
+            16 => {
+                let digits: String = self
+                    .digits
+                    .iter()
+                    .map(|d| (if *d < 10 { b'0' + d } else { b'a' + (d - 10) }) as char)
+                    .collect();
+                write!(f, "{}", digits)
+            }
+            26 => {
+                let digits: String = self.digits.iter().map(|d| (b'a' + d) as char).collect();
+                write!(f, "{}", digits)
+            }
+            _ => Err(fmt::Error),
+        }
+    }
+}
+
+/// A positional notation representation of a number of dynamically growing width.
+///
+/// The digits are represented as a [`Vec<u8>`] with the most
+/// significant digit on the left and the least significant digit on
+/// the right. Each digit is a nonnegative integer less than the
+/// radix.
+///
+/// # Incrementing
+///
+/// This number starts at `vec![0, 0]`, representing the number 0 with
+/// a width of 2 digits. Incrementing this number with
+/// [`Number::increment`] causes it to increase its value by 1. When
+/// incrementing the number would have caused it to change from
+/// `vec![radix - 2, radix - 1]` to `vec![radix - 1, 0]`, it instead
+/// increases its width by one and resets its value to 0. For example,
+/// if the radix were 3, the digits were `vec![1, 2]`, and we called
+/// [`Number::increment`], then the digits would become `vec![0, 0,
+/// 0]`. In this way, the width grows by one each time the most
+/// significant digit would have achieved its maximum value.
+///
+/// This notion of "incrementing" here does not match the notion of
+/// incrementing the *value* of the number, it is just an abstract way
+/// of updating the representation of the number in a way that is only
+/// useful for the purposes of the `split` program.
+///
+/// # Displaying
+///
+/// This number is only displayable if `radix` is 10, 16, or 26. If
+/// `radix` is 10 or 16, then the digits are concatenated and
+/// displayed as a fixed-width decimal or hexadecimal number,
+/// respectively, with a prefix of `n - 2` instances of the character
+/// '9' of 'f', respectively, where `n` is the number of digits.  If
+/// `radix` is 26, then each digit is translated to the corresponding
+/// lowercase ASCII alphabetic character (that is, 'a', 'b', 'c',
+/// etc.) and concatenated with a prefix of `n - 2` instances of the
+/// character 'z'.
+///
+/// This notion of displaying the number is specific to the `split`
+/// program.
+#[derive(Clone)]
+pub struct DynamicWidthNumber {
+    radix: u8,
+    digits: Vec<u8>,
+}
+
+impl DynamicWidthNumber {
+    /// Instantiate a number of the given radix, starting with width 2.
+    ///
+    /// This associated function returns a new instance of the struct
+    /// with the given radix and a width of two digits, both 0.
+    pub fn new(radix: u8) -> Self {
+        Self {
+            radix,
+            digits: vec![0, 0],
+        }
+    }
+
+    /// Set all digits to zero.
+    fn reset(&mut self) {
+        for i in 0..self.digits.len() {
+            self.digits[i] = 0;
+        }
+    }
+
+    /// Increment this number.
+    ///
+    /// This method adds one to this number. The first time that the
+    /// most significant digit would achieve its highest possible
+    /// value (that is, `radix - 1`), then all the digits get reset to
+    /// 0 and the number of digits increases by one.
+    ///
+    /// This method never returns an error.
+    fn increment(&mut self) -> Result<(), Overflow> {
+        for i in (0..self.digits.len()).rev() {
+            // Increment the current digit.
+            self.digits[i] += 1;
+
+            // If the digit overflows, then set it to 0 and continue
+            // to the next iteration to increment the next most
+            // significant digit. Otherwise, terminate the loop, since
+            // there will be no further changes to any higher order
+            // digits.
+            if self.digits[i] == self.radix {
+                self.digits[i] = 0;
+            } else {
+                break;
+            }
+        }
+
+        // If the most significant digit is at its maximum value, then
+        // add another digit and reset all digits zero.
+        if self.digits[0] == self.radix - 1 {
+            self.digits.push(0);
+            self.reset();
+        }
+        Ok(())
+    }
+}
+
+impl Display for DynamicWidthNumber {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self.radix {
+            10 => {
+                let num_fill_chars = self.digits.len() - 2;
+                let digits: String = self.digits.iter().map(|d| (b'0' + d) as char).collect();
+                write!(
+                    f,
+                    "{empty:9<num_fill_chars$}{digits}",
+                    empty = "",
+                    num_fill_chars = num_fill_chars,
+                    digits = digits,
+                )
+            }
+            16 => {
+                let num_fill_chars = self.digits.len() - 2;
+                let digits: String = self
+                    .digits
+                    .iter()
+                    .map(|d| (if *d < 10 { b'0' + d } else { b'a' + (d - 10) }) as char)
+                    .collect();
+                write!(
+                    f,
+                    "{empty:f<num_fill_chars$}{digits}",
+                    empty = "",
+                    num_fill_chars = num_fill_chars,
+                    digits = digits,
+                )
+            }
+            26 => {
+                let num_fill_chars = self.digits.len() - 2;
+                let digits: String = self.digits.iter().map(|d| (b'a' + d) as char).collect();
+                write!(
+                    f,
+                    "{empty:z<num_fill_chars$}{digits}",
+                    empty = "",
+                    num_fill_chars = num_fill_chars,
+                    digits = digits,
+                )
+            }
+            _ => Err(fmt::Error),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::number::DynamicWidthNumber;
+    use crate::number::FixedWidthNumber;
+    use crate::number::Number;
+    use crate::number::Overflow;
+
+    #[test]
+    fn test_dynamic_width_number_increment() {
+        let mut n = Number::DynamicWidth(DynamicWidthNumber::new(3));
+        assert_eq!(n.digits(), &vec![0, 0]);
+
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![0, 1]);
+
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![0, 2]);
+
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![1, 0]);
+
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![1, 1]);
+
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![1, 2]);
+
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![0, 0, 0]);
+
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![0, 0, 1]);
+    }
+
+    #[test]
+    fn test_dynamic_width_number_display_alphabetic() {
+        fn num(n: usize) -> Number {
+            let mut number = Number::DynamicWidth(DynamicWidthNumber::new(26));
+            for _ in 0..n {
+                number.increment().unwrap();
+            }
+            number
+        }
+
+        assert_eq!(format!("{}", num(0)), "aa");
+        assert_eq!(format!("{}", num(1)), "ab");
+        assert_eq!(format!("{}", num(2)), "ac");
+        assert_eq!(format!("{}", num(25)), "az");
+        assert_eq!(format!("{}", num(26)), "ba");
+        assert_eq!(format!("{}", num(27)), "bb");
+        assert_eq!(format!("{}", num(28)), "bc");
+        assert_eq!(format!("{}", num(26 + 25)), "bz");
+        assert_eq!(format!("{}", num(26 + 26)), "ca");
+        assert_eq!(format!("{}", num(26 * 25 - 1)), "yz");
+        assert_eq!(format!("{}", num(26 * 25)), "zaaa");
+        assert_eq!(format!("{}", num(26 * 25 + 1)), "zaab");
+    }
+
+    #[test]
+    fn test_dynamic_width_number_display_numeric_decimal() {
+        fn num(n: usize) -> Number {
+            let mut number = Number::DynamicWidth(DynamicWidthNumber::new(10));
+            for _ in 0..n {
+                number.increment().unwrap();
+            }
+            number
+        }
+
+        assert_eq!(format!("{}", num(0)), "00");
+        assert_eq!(format!("{}", num(9)), "09");
+        assert_eq!(format!("{}", num(17)), "17");
+        assert_eq!(format!("{}", num(10 * 9 - 1)), "89");
+        assert_eq!(format!("{}", num(10 * 9)), "9000");
+        assert_eq!(format!("{}", num(10 * 9 + 1)), "9001");
+        assert_eq!(format!("{}", num(10 * 99 - 1)), "9899");
+        assert_eq!(format!("{}", num(10 * 99)), "990000");
+        assert_eq!(format!("{}", num(10 * 99 + 1)), "990001");
+    }
+
+    #[test]
+    fn test_dynamic_width_number_display_numeric_hexadecimal() {
+        fn num(n: usize) -> Number {
+            let mut number = Number::DynamicWidth(DynamicWidthNumber::new(16));
+            for _ in 0..n {
+                number.increment().unwrap();
+            }
+            number
+        }
+
+        assert_eq!(format!("{}", num(0)), "00");
+        assert_eq!(format!("{}", num(15)), "0f");
+        assert_eq!(format!("{}", num(16)), "10");
+        assert_eq!(format!("{}", num(17)), "11");
+        assert_eq!(format!("{}", num(18)), "12");
+
+        assert_eq!(format!("{}", num(16 * 15 - 1)), "ef");
+        assert_eq!(format!("{}", num(16 * 15)), "f000");
+        assert_eq!(format!("{}", num(16 * 15 + 1)), "f001");
+        assert_eq!(format!("{}", num(16 * 255 - 1)), "feff");
+        assert_eq!(format!("{}", num(16 * 255)), "ff0000");
+        assert_eq!(format!("{}", num(16 * 255 + 1)), "ff0001");
+    }
+
+    #[test]
+    fn test_fixed_width_number_increment() {
+        let mut n = Number::FixedWidth(FixedWidthNumber::new(3, 2));
+        assert_eq!(n.digits(), &vec![0, 0]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![0, 1]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![0, 2]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![1, 0]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![1, 1]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![1, 2]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![2, 0]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![2, 1]);
+        n.increment().unwrap();
+        assert_eq!(n.digits(), &vec![2, 2]);
+        assert!(n.increment().is_err());
+    }
+
+    #[test]
+    fn test_fixed_width_number_display_alphabetic() {
+        fn num(n: usize) -> Result<Number, Overflow> {
+            let mut number = Number::FixedWidth(FixedWidthNumber::new(26, 2));
+            for _ in 0..n {
+                number.increment()?;
+            }
+            Ok(number)
+        }
+
+        assert_eq!(format!("{}", num(0).unwrap()), "aa");
+        assert_eq!(format!("{}", num(1).unwrap()), "ab");
+        assert_eq!(format!("{}", num(2).unwrap()), "ac");
+        assert_eq!(format!("{}", num(25).unwrap()), "az");
+        assert_eq!(format!("{}", num(26).unwrap()), "ba");
+        assert_eq!(format!("{}", num(27).unwrap()), "bb");
+        assert_eq!(format!("{}", num(28).unwrap()), "bc");
+        assert_eq!(format!("{}", num(26 + 25).unwrap()), "bz");
+        assert_eq!(format!("{}", num(26 + 26).unwrap()), "ca");
+        assert_eq!(format!("{}", num(26 * 25 - 1).unwrap()), "yz");
+        assert_eq!(format!("{}", num(26 * 25).unwrap()), "za");
+        assert_eq!(format!("{}", num(26 * 26 - 1).unwrap()), "zz");
+        assert!(num(26 * 26).is_err());
+    }
+
+    #[test]
+    fn test_fixed_width_number_display_numeric_decimal() {
+        fn num(n: usize) -> Result<Number, Overflow> {
+            let mut number = Number::FixedWidth(FixedWidthNumber::new(10, 2));
+            for _ in 0..n {
+                number.increment()?;
+            }
+            Ok(number)
+        }
+
+        assert_eq!(format!("{}", num(0).unwrap()), "00");
+        assert_eq!(format!("{}", num(9).unwrap()), "09");
+        assert_eq!(format!("{}", num(17).unwrap()), "17");
+        assert_eq!(format!("{}", num(10 * 9 - 1).unwrap()), "89");
+        assert_eq!(format!("{}", num(10 * 9).unwrap()), "90");
+        assert_eq!(format!("{}", num(10 * 10 - 1).unwrap()), "99");
+        assert!(num(10 * 10).is_err());
+    }
+
+    #[test]
+    fn test_fixed_width_number_display_numeric_hexadecimal() {
+        fn num(n: usize) -> Result<Number, Overflow> {
+            let mut number = Number::FixedWidth(FixedWidthNumber::new(16, 2));
+            for _ in 0..n {
+                number.increment()?;
+            }
+            Ok(number)
+        }
+
+        assert_eq!(format!("{}", num(0).unwrap()), "00");
+        assert_eq!(format!("{}", num(15).unwrap()), "0f");
+        assert_eq!(format!("{}", num(17).unwrap()), "11");
+        assert_eq!(format!("{}", num(16 * 15 - 1).unwrap()), "ef");
+        assert_eq!(format!("{}", num(16 * 15).unwrap()), "f0");
+        assert_eq!(format!("{}", num(16 * 16 - 1).unwrap()), "ff");
+        assert!(num(16 * 16).is_err());
+    }
+}
diff --git a/src/uu/split/src/platform/unix.rs b/src/uu/split/src/platform/unix.rs
index a115d1959..f6bac702b 100644
--- a/src/uu/split/src/platform/unix.rs
+++ b/src/uu/split/src/platform/unix.rs
@@ -2,6 +2,8 @@ use std::env;
 use std::io::Write;
 use std::io::{BufWriter, Result};
 use std::process::{Child, Command, Stdio};
+use uucore::crash;
+
 /// A writer that writes to a shell_process' stdin
 ///
 /// We use a shell process (not directly calling a sub-process) so we can forward the name of the
@@ -37,10 +39,10 @@ struct WithEnvVarSet {
 }
 impl WithEnvVarSet {
     /// Save previous value assigned to key, set key=value
-    fn new(key: &str, value: &str) -> WithEnvVarSet {
+    fn new(key: &str, value: &str) -> Self {
         let previous_env_value = env::var(key);
         env::set_var(key, value);
-        WithEnvVarSet {
+        Self {
             _previous_var_key: String::from(key),
             _previous_var_value: previous_env_value,
         }
@@ -53,7 +55,7 @@ impl Drop for WithEnvVarSet {
         if let Ok(ref prev_value) = self._previous_var_value {
             env::set_var(&self._previous_var_key, &prev_value);
         } else {
-            env::remove_var(&self._previous_var_key)
+            env::remove_var(&self._previous_var_key);
         }
     }
 }
@@ -64,7 +66,7 @@ impl FilterWriter {
     ///
     /// * `command` - The shell command to execute
     /// * `filepath` - Path of the output file (forwarded to command as $FILE)
-    fn new(command: &str, filepath: &str) -> FilterWriter {
+    fn new(command: &str, filepath: &str) -> Self {
         // set $FILE, save previous value (if there was one)
         let _with_env_var_set = WithEnvVarSet::new("FILE", filepath);
 
@@ -76,7 +78,7 @@ impl FilterWriter {
                 .spawn()
                 .expect("Couldn't spawn filter command");
 
-        FilterWriter { shell_process }
+        Self { shell_process }
     }
 }
 
diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs
index 581b632d2..b64b92898 100644
--- a/src/uu/split/src/split.rs
+++ b/src/uu/split/src/split.rs
@@ -5,425 +5,1344 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) PREFIXaa
-
-#[macro_use]
-extern crate uucore;
+// spell-checker:ignore (ToDO) PREFIXaa nbbbb ncccc
 
+mod filenames;
+mod number;
 mod platform;
 
-use clap::{crate_version, App, Arg};
-use std::convert::TryFrom;
+use crate::filenames::FilenameIterator;
+use crate::filenames::SuffixType;
+use clap::{crate_version, Arg, ArgMatches, Command};
+use std::convert::TryInto;
 use std::env;
-use std::fs::File;
-use std::io::{stdin, BufRead, BufReader, BufWriter, Read, Write};
+use std::fmt;
+use std::fs::{metadata, File};
+use std::io;
+use std::io::{stdin, BufRead, BufReader, BufWriter, ErrorKind, Read, Write};
 use std::path::Path;
-use std::{char, fs::remove_file};
 use uucore::display::Quotable;
-use uucore::parse_size::parse_size;
+use uucore::error::{FromIo, UIoError, UResult, USimpleError, UUsageError};
+use uucore::format_usage;
+use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::uio_error;
 
 static OPT_BYTES: &str = "bytes";
 static OPT_LINE_BYTES: &str = "line-bytes";
 static OPT_LINES: &str = "lines";
 static OPT_ADDITIONAL_SUFFIX: &str = "additional-suffix";
 static OPT_FILTER: &str = "filter";
+static OPT_NUMBER: &str = "number";
 static OPT_NUMERIC_SUFFIXES: &str = "numeric-suffixes";
+static OPT_HEX_SUFFIXES: &str = "hex-suffixes";
 static OPT_SUFFIX_LENGTH: &str = "suffix-length";
-static OPT_DEFAULT_SUFFIX_LENGTH: &str = "2";
+static OPT_DEFAULT_SUFFIX_LENGTH: &str = "0";
 static OPT_VERBOSE: &str = "verbose";
+//The ---io-blksize parameter is consumed and ignored.
+//The parameter is included to make GNU coreutils tests pass.
+static OPT_IO_BLKSIZE: &str = "-io-blksize";
+static OPT_ELIDE_EMPTY_FILES: &str = "elide-empty-files";
 
 static ARG_INPUT: &str = "input";
 static ARG_PREFIX: &str = "prefix";
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [INPUT [PREFIX]]",
-        uucore::execution_phrase()
-    )
-}
-fn get_long_usage() -> String {
-    format!(
-        "Usage:
-  {0}
+const USAGE: &str = "{} [OPTION]... [INPUT [PREFIX]]";
+const AFTER_HELP: &str = "\
+    Output fixed-size pieces of INPUT to PREFIXaa, PREFIX ab, ...; default \
+    size is 1000, and default PREFIX is 'x'. With no INPUT, or when INPUT is \
+    -, read standard input.";
 
-Output fixed-size pieces of INPUT to PREFIXaa, PREFIX ab, ...; default
-size is 1000, and default PREFIX is 'x'. With no INPUT, or when INPUT is
--, read standard input.",
-        usage()
-    )
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
+    match Settings::from(&matches) {
+        Ok(settings) => split(&settings),
+        Err(e) if e.requires_usage() => Err(UUsageError::new(1, format!("{}", e))),
+        Err(e) => Err(USimpleError::new(1, format!("{}", e))),
+    }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-    let long_usage = get_long_usage();
-
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&long_usage[..])
-        .get_matches_from(args);
-
-    let mut settings = Settings {
-        prefix: "".to_owned(),
-        numeric_suffix: false,
-        suffix_length: 0,
-        additional_suffix: "".to_owned(),
-        input: "".to_owned(),
-        filter: None,
-        strategy: "".to_owned(),
-        strategy_param: "".to_owned(),
-        verbose: false,
-    };
-
-    settings.suffix_length = matches
-        .value_of(OPT_SUFFIX_LENGTH)
-        .unwrap()
-        .parse()
-        .unwrap_or_else(|_| panic!("Invalid number for {}", OPT_SUFFIX_LENGTH));
-
-    settings.numeric_suffix = matches.occurrences_of(OPT_NUMERIC_SUFFIXES) > 0;
-    settings.additional_suffix = matches.value_of(OPT_ADDITIONAL_SUFFIX).unwrap().to_owned();
-
-    settings.verbose = matches.occurrences_of("verbose") > 0;
-    // check that the user is not specifying more than one strategy
-    // note: right now, this exact behavior cannot be handled by ArgGroup since ArgGroup
-    // considers a default value Arg as "defined"
-    let explicit_strategies =
-        vec![OPT_LINE_BYTES, OPT_LINES, OPT_BYTES]
-            .into_iter()
-            .fold(0, |count, strategy| {
-                if matches.occurrences_of(strategy) > 0 {
-                    count + 1
-                } else {
-                    count
-                }
-            });
-    if explicit_strategies > 1 {
-        crash!(1, "cannot split in more than one way");
-    }
-
-    // default strategy (if no strategy is passed, use this one)
-    settings.strategy = String::from(OPT_LINES);
-    settings.strategy_param = matches.value_of(OPT_LINES).unwrap().to_owned();
-    // take any (other) defined strategy
-    for &strategy in &[OPT_LINE_BYTES, OPT_BYTES] {
-        if matches.occurrences_of(strategy) > 0 {
-            settings.strategy = String::from(strategy);
-            settings.strategy_param = matches.value_of(strategy).unwrap().to_owned();
-        }
-    }
-
-    settings.input = matches.value_of(ARG_INPUT).unwrap().to_owned();
-    settings.prefix = matches.value_of(ARG_PREFIX).unwrap().to_owned();
-
-    if matches.occurrences_of(OPT_FILTER) > 0 {
-        if cfg!(windows) {
-            // see https://github.com/rust-lang/rust/issues/29494
-            show_error!("{} is currently not supported in this platform", OPT_FILTER);
-            exit!(-1);
-        } else {
-            settings.filter = Some(matches.value_of(OPT_FILTER).unwrap().to_owned());
-        }
-    }
-
-    split(&settings)
-}
-
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about("Create output files containing consecutive or interleaved sections of input")
+        .after_help(AFTER_HELP)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         // strategy (mutually exclusive)
         .arg(
-            Arg::with_name(OPT_BYTES)
-                .short("b")
+            Arg::new(OPT_BYTES)
+                .short('b')
                 .long(OPT_BYTES)
                 .takes_value(true)
-                .default_value("2")
-                .help("use suffixes of length N (default 2)"),
+                .help("put SIZE bytes per output file"),
         )
         .arg(
-            Arg::with_name(OPT_LINE_BYTES)
-                .short("C")
+            Arg::new(OPT_LINE_BYTES)
+                .short('C')
                 .long(OPT_LINE_BYTES)
                 .takes_value(true)
                 .default_value("2")
                 .help("put at most SIZE bytes of lines per output file"),
         )
         .arg(
-            Arg::with_name(OPT_LINES)
-                .short("l")
+            Arg::new(OPT_LINES)
+                .short('l')
                 .long(OPT_LINES)
                 .takes_value(true)
                 .default_value("1000")
-                .help("write to shell COMMAND file name is $FILE (Currently not implemented for Windows)"),
+                .help("put NUMBER lines/records per output file"),
+        )
+        .arg(
+            Arg::new(OPT_NUMBER)
+                .short('n')
+                .long(OPT_NUMBER)
+                .takes_value(true)
+                .help("generate CHUNKS output files; see explanation below"),
         )
         // rest of the arguments
         .arg(
-            Arg::with_name(OPT_ADDITIONAL_SUFFIX)
+            Arg::new(OPT_ADDITIONAL_SUFFIX)
                 .long(OPT_ADDITIONAL_SUFFIX)
                 .takes_value(true)
                 .default_value("")
                 .help("additional suffix to append to output file names"),
         )
         .arg(
-            Arg::with_name(OPT_FILTER)
+            Arg::new(OPT_FILTER)
                 .long(OPT_FILTER)
                 .takes_value(true)
-                .help("write to shell COMMAND file name is $FILE (Currently not implemented for Windows)"),
+                .help(
+                "write to shell COMMAND file name is $FILE (Currently not implemented for Windows)",
+            ),
         )
         .arg(
-            Arg::with_name(OPT_NUMERIC_SUFFIXES)
-                .short("d")
+            Arg::new(OPT_ELIDE_EMPTY_FILES)
+                .long(OPT_ELIDE_EMPTY_FILES)
+                .short('e')
+                .takes_value(false)
+                .help("do not generate empty output files with '-n'"),
+        )
+        .arg(
+            Arg::new(OPT_NUMERIC_SUFFIXES)
+                .short('d')
                 .long(OPT_NUMERIC_SUFFIXES)
                 .takes_value(true)
-                .default_value("0")
+                .default_missing_value("0")
                 .help("use numeric suffixes instead of alphabetic"),
         )
         .arg(
-            Arg::with_name(OPT_SUFFIX_LENGTH)
-                .short("a")
+            Arg::new(OPT_SUFFIX_LENGTH)
+                .short('a')
                 .long(OPT_SUFFIX_LENGTH)
                 .takes_value(true)
                 .default_value(OPT_DEFAULT_SUFFIX_LENGTH)
                 .help("use suffixes of length N (default 2)"),
         )
         .arg(
-            Arg::with_name(OPT_VERBOSE)
+            Arg::new(OPT_HEX_SUFFIXES)
+                .short('x')
+                .long(OPT_HEX_SUFFIXES)
+                .takes_value(true)
+                .default_missing_value("0")
+                .help("use hex suffixes instead of alphabetic"),
+        )
+        .arg(
+            Arg::new(OPT_VERBOSE)
                 .long(OPT_VERBOSE)
                 .help("print a diagnostic just before each output file is opened"),
         )
         .arg(
-            Arg::with_name(ARG_INPUT)
-            .takes_value(true)
-            .default_value("-")
-            .index(1)
+            Arg::new(OPT_IO_BLKSIZE)
+                .long(OPT_IO_BLKSIZE)
+                .alias(OPT_IO_BLKSIZE)
+                .takes_value(true)
+                .hide(true),
         )
         .arg(
-            Arg::with_name(ARG_PREFIX)
-            .takes_value(true)
-            .default_value("x")
-            .index(2)
+            Arg::new(ARG_INPUT)
+                .takes_value(true)
+                .default_value("-")
+                .index(1),
+        )
+        .arg(
+            Arg::new(ARG_PREFIX)
+                .takes_value(true)
+                .default_value("x")
+                .index(2),
         )
 }
 
-#[allow(dead_code)]
+/// Sub-strategy to use when splitting a file into a specific number of chunks.
+#[derive(Debug, PartialEq)]
+enum NumberType {
+    /// Split into a specific number of chunks by byte.
+    Bytes(u64),
+
+    /// Split into a specific number of chunks by line (approximately).
+    Lines(u64),
+
+    /// Split into a specific number of chunks by line
+    /// (approximately), but output only the *k*th chunk.
+    KthLines(u64, u64),
+
+    /// Assign lines via round-robin to the specified number of output chunks.
+    RoundRobin(u64),
+
+    /// Assign lines via round-robin to the specified number of output
+    /// chunks, but output only the *k*th chunk.
+    KthRoundRobin(u64, u64),
+}
+
+impl NumberType {
+    /// The number of chunks for this number type.
+    fn num_chunks(&self) -> u64 {
+        match self {
+            Self::Bytes(n) => *n,
+            Self::Lines(n) => *n,
+            Self::KthLines(_, n) => *n,
+            Self::RoundRobin(n) => *n,
+            Self::KthRoundRobin(_, n) => *n,
+        }
+    }
+}
+
+/// An error due to an invalid parameter to the `-n` command-line option.
+#[derive(Debug, PartialEq)]
+enum NumberTypeError {
+    /// The number of chunks was invalid.
+    ///
+    /// This can happen if the value of `N` in any of the following
+    /// command-line options is not a positive integer:
+    ///
+    /// ```ignore
+    /// -n N
+    /// -n l/N
+    /// -n l/K/N
+    /// -n r/N
+    /// -n r/K/N
+    /// ```
+    NumberOfChunks(String),
+
+    /// The chunk number was invalid.
+    ///
+    /// This can happen if the value of `K` in any of the following
+    /// command-line options is not a positive integer:
+    ///
+    /// ```ignore
+    /// -n l/K/N
+    /// -n r/K/N
+    /// ```
+    ChunkNumber(String),
+}
+
+impl NumberType {
+    /// Parse a `NumberType` from a string.
+    ///
+    /// The following strings are valid arguments:
+    ///
+    /// ```ignore
+    /// "N"
+    /// "l/N"
+    /// "l/K/N"
+    /// "r/N"
+    /// "r/K/N"
+    /// ```
+    ///
+    /// The `N` represents the number of chunks and the `K` represents
+    /// a chunk number.
+    ///
+    /// # Errors
+    ///
+    /// If the string is not one of the valid number types, if `K` is
+    /// not a nonnegative integer, or if `N` is not a positive
+    /// integer, then this function returns [`NumberTypeError`].
+    fn from(s: &str) -> Result<Self, NumberTypeError> {
+        let parts: Vec<&str> = s.split('/').collect();
+        match &parts[..] {
+            [n_str] => {
+                let num_chunks = n_str
+                    .parse()
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                Ok(Self::Bytes(num_chunks))
+            }
+            ["l", n_str] => {
+                let num_chunks = n_str
+                    .parse()
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                Ok(Self::Lines(num_chunks))
+            }
+            ["l", k_str, n_str] => {
+                let num_chunks = n_str
+                    .parse()
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                let chunk_number = k_str
+                    .parse()
+                    .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+                Ok(Self::KthLines(chunk_number, num_chunks))
+            }
+            ["r", n_str] => {
+                let num_chunks = n_str
+                    .parse()
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                Ok(Self::RoundRobin(num_chunks))
+            }
+            ["r", k_str, n_str] => {
+                let num_chunks = n_str
+                    .parse()
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                let chunk_number = k_str
+                    .parse()
+                    .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+                Ok(Self::KthRoundRobin(chunk_number, num_chunks))
+            }
+            _ => Err(NumberTypeError::NumberOfChunks(s.to_string())),
+        }
+    }
+}
+
+/// The strategy for breaking up the input file into chunks.
+enum Strategy {
+    /// Each chunk has the specified number of lines.
+    Lines(u64),
+
+    /// Each chunk has the specified number of bytes.
+    Bytes(u64),
+
+    /// Each chunk has as many lines as possible without exceeding the
+    /// specified number of bytes.
+    LineBytes(u64),
+
+    /// Split the file into this many chunks.
+    ///
+    /// There are several sub-strategies available, as defined by
+    /// [`NumberType`].
+    Number(NumberType),
+}
+
+/// An error when parsing a chunking strategy from command-line arguments.
+enum StrategyError {
+    /// Invalid number of lines.
+    Lines(ParseSizeError),
+
+    /// Invalid number of bytes.
+    Bytes(ParseSizeError),
+
+    /// Invalid number type.
+    NumberType(NumberTypeError),
+
+    /// Multiple chunking strategies were specified (but only one should be).
+    MultipleWays,
+}
+
+impl fmt::Display for StrategyError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            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)
+            }
+            Self::NumberType(NumberTypeError::ChunkNumber(s)) => {
+                write!(f, "invalid chunk number: {}", s)
+            }
+            Self::MultipleWays => write!(f, "cannot split in more than one way"),
+        }
+    }
+}
+
+impl Strategy {
+    /// Parse a strategy from the command-line arguments.
+    fn from(matches: &ArgMatches) -> Result<Self, StrategyError> {
+        // Check that the user is not specifying more than one strategy.
+        //
+        // Note: right now, this exact behavior cannot be handled by
+        // `ArgGroup` since `ArgGroup` considers a default value `Arg`
+        // as "defined".
+        match (
+            matches.occurrences_of(OPT_LINES),
+            matches.occurrences_of(OPT_BYTES),
+            matches.occurrences_of(OPT_LINE_BYTES),
+            matches.occurrences_of(OPT_NUMBER),
+        ) {
+            (0, 0, 0, 0) => Ok(Self::Lines(1000)),
+            (1, 0, 0, 0) => {
+                let s = matches.value_of(OPT_LINES).unwrap();
+                let n = parse_size(s).map_err(StrategyError::Lines)?;
+                Ok(Self::Lines(n))
+            }
+            (0, 1, 0, 0) => {
+                let s = matches.value_of(OPT_BYTES).unwrap();
+                let n = parse_size(s).map_err(StrategyError::Bytes)?;
+                Ok(Self::Bytes(n))
+            }
+            (0, 0, 1, 0) => {
+                let s = matches.value_of(OPT_LINE_BYTES).unwrap();
+                let n = parse_size(s).map_err(StrategyError::Bytes)?;
+                Ok(Self::LineBytes(n))
+            }
+            (0, 0, 0, 1) => {
+                let s = matches.value_of(OPT_NUMBER).unwrap();
+                let number_type = NumberType::from(s).map_err(StrategyError::NumberType)?;
+                Ok(Self::Number(number_type))
+            }
+            _ => Err(StrategyError::MultipleWays),
+        }
+    }
+}
+
+/// Parse the suffix type from the command-line arguments.
+fn suffix_type_from(matches: &ArgMatches) -> SuffixType {
+    if matches.occurrences_of(OPT_NUMERIC_SUFFIXES) > 0 {
+        SuffixType::Decimal
+    } else if matches.occurrences_of(OPT_HEX_SUFFIXES) > 0 {
+        SuffixType::Hexadecimal
+    } else {
+        SuffixType::Alphabetic
+    }
+}
+
+/// Parameters that control how a file gets split.
+///
+/// You can convert an [`ArgMatches`] instance into a [`Settings`]
+/// instance by calling [`Settings::from`].
 struct Settings {
     prefix: String,
-    numeric_suffix: bool,
+    suffix_type: SuffixType,
     suffix_length: usize,
     additional_suffix: String,
     input: String,
     /// When supplied, a shell command to output to instead of xaa, xab …
     filter: Option<String>,
-    strategy: String,
-    strategy_param: String,
-    verbose: bool, // TODO: warning: field is never read: `verbose`
+    strategy: Strategy,
+    verbose: bool,
+
+    /// Whether to *not* produce empty files when using `-n`.
+    ///
+    /// The `-n` command-line argument gives a specific number of
+    /// chunks into which the input files will be split. If the number
+    /// of chunks is greater than the number of bytes, and this is
+    /// `false`, then empty files will be created for the excess
+    /// chunks. If this is `false`, then empty files will not be
+    /// created.
+    elide_empty_files: bool,
 }
 
-trait Splitter {
-    // Consume as much as possible from `reader` so as to saturate `writer`.
-    // Equivalent to finishing one of the part files. Returns the number of
-    // bytes that have been moved.
-    fn consume(
-        &mut self,
-        reader: &mut BufReader<Box<dyn Read>>,
-        writer: &mut BufWriter<Box<dyn Write>>,
-    ) -> u128;
+/// An error when parsing settings from command-line arguments.
+enum SettingsError {
+    /// Invalid chunking strategy.
+    Strategy(StrategyError),
+
+    /// Invalid suffix length parameter.
+    SuffixNotParsable(String),
+
+    /// Suffix contains a directory separator, which is not allowed.
+    SuffixContainsSeparator(String),
+
+    /// Suffix is not large enough to split into specified chunks
+    SuffixTooSmall(usize),
+
+    /// The `--filter` option is not supported on Windows.
+    #[cfg(windows)]
+    NotSupported,
 }
 
-struct LineSplitter {
-    lines_per_split: usize,
+impl SettingsError {
+    /// Whether the error demands a usage message.
+    fn requires_usage(&self) -> bool {
+        matches!(
+            self,
+            Self::Strategy(StrategyError::MultipleWays) | Self::SuffixContainsSeparator(_)
+        )
+    }
 }
 
-impl LineSplitter {
-    fn new(settings: &Settings) -> LineSplitter {
-        LineSplitter {
-            lines_per_split: settings.strategy_param.parse().unwrap_or_else(|_| {
-                crash!(
-                    1,
-                    "invalid number of lines: {}",
-                    settings.strategy_param.quote()
-                )
-            }),
+impl fmt::Display for SettingsError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Strategy(e) => e.fmt(f),
+            Self::SuffixNotParsable(s) => write!(f, "invalid suffix length: {}", s.quote()),
+            Self::SuffixTooSmall(i) => write!(f, "the suffix length needs to be at least {}", i),
+            Self::SuffixContainsSeparator(s) => write!(
+                f,
+                "invalid suffix {}, contains directory separator",
+                s.quote()
+            ),
+            #[cfg(windows)]
+            Self::NotSupported => write!(
+                f,
+                "{} is currently not supported in this platform",
+                OPT_FILTER
+            ),
         }
     }
 }
 
-impl Splitter for LineSplitter {
-    fn consume(
-        &mut self,
-        reader: &mut BufReader<Box<dyn Read>>,
-        writer: &mut BufWriter<Box<dyn Write>>,
-    ) -> u128 {
-        let mut bytes_consumed = 0u128;
-        let mut buffer = String::with_capacity(1024);
-        for _ in 0..self.lines_per_split {
-            let bytes_read = reader
-                .read_line(&mut buffer)
-                .unwrap_or_else(|_| crash!(1, "error reading bytes from input file"));
-            // If we ever read 0 bytes then we know we've hit EOF.
-            if bytes_read == 0 {
-                return bytes_consumed;
+impl Settings {
+    /// Parse a strategy from the command-line arguments.
+    fn from(matches: &ArgMatches) -> Result<Self, SettingsError> {
+        let additional_suffix = matches.value_of(OPT_ADDITIONAL_SUFFIX).unwrap().to_string();
+        if additional_suffix.contains('/') {
+            return Err(SettingsError::SuffixContainsSeparator(additional_suffix));
+        }
+        let strategy = Strategy::from(matches).map_err(SettingsError::Strategy)?;
+        let suffix_type = suffix_type_from(matches);
+        let suffix_length_str = matches.value_of(OPT_SUFFIX_LENGTH).unwrap();
+        let suffix_length: usize = suffix_length_str
+            .parse()
+            .map_err(|_| SettingsError::SuffixNotParsable(suffix_length_str.to_string()))?;
+        if let Strategy::Number(ref number_type) = strategy {
+            let chunks = number_type.num_chunks();
+            if suffix_length != 0 {
+                let required_suffix_length =
+                    (chunks as f64).log(suffix_type.radix() as f64).ceil() as usize;
+                if suffix_length < required_suffix_length {
+                    return Err(SettingsError::SuffixTooSmall(required_suffix_length));
+                }
             }
-
-            writer
-                .write_all(buffer.as_bytes())
-                .unwrap_or_else(|_| crash!(1, "error writing bytes to output file"));
-            // Empty out the String buffer since `read_line` appends instead of
-            // replaces.
-            buffer.clear();
-
-            bytes_consumed += bytes_read as u128;
         }
-
-        bytes_consumed
-    }
-}
-
-struct ByteSplitter {
-    bytes_per_split: u128,
-}
-
-impl ByteSplitter {
-    fn new(settings: &Settings) -> ByteSplitter {
-        let size_string = &settings.strategy_param;
-        let size_num = match parse_size(size_string) {
-            Ok(n) => n,
-            Err(e) => crash!(1, "invalid number of bytes: {}", e.to_string()),
+        let result = Self {
+            suffix_length: suffix_length_str
+                .parse()
+                .map_err(|_| SettingsError::SuffixNotParsable(suffix_length_str.to_string()))?,
+            suffix_type,
+            additional_suffix,
+            verbose: matches.occurrences_of("verbose") > 0,
+            strategy,
+            input: matches.value_of(ARG_INPUT).unwrap().to_owned(),
+            prefix: matches.value_of(ARG_PREFIX).unwrap().to_owned(),
+            filter: matches.value_of(OPT_FILTER).map(|s| s.to_owned()),
+            elide_empty_files: matches.is_present(OPT_ELIDE_EMPTY_FILES),
         };
-
-        ByteSplitter {
-            bytes_per_split: u128::try_from(size_num).unwrap(),
+        #[cfg(windows)]
+        if result.filter.is_some() {
+            // see https://github.com/rust-lang/rust/issues/29494
+            return Err(SettingsError::NotSupported);
         }
+
+        Ok(result)
     }
 }
 
-impl Splitter for ByteSplitter {
-    fn consume(
-        &mut self,
-        reader: &mut BufReader<Box<dyn Read>>,
-        writer: &mut BufWriter<Box<dyn Write>>,
-    ) -> u128 {
-        // We buffer reads and writes. We proceed until `bytes_consumed` is
-        // equal to `self.bytes_per_split` or we reach EOF.
-        let mut bytes_consumed = 0u128;
-        const BUFFER_SIZE: usize = 1024;
-        let mut buffer = [0u8; BUFFER_SIZE];
-        while bytes_consumed < self.bytes_per_split {
-            // Don't overshoot `self.bytes_per_split`! Note: Using std::cmp::min
-            // doesn't really work since we have to get types to match which
-            // can't be done in a way that keeps all conversions safe.
-            let bytes_desired = if (BUFFER_SIZE as u128) <= self.bytes_per_split - bytes_consumed {
-                BUFFER_SIZE
-            } else {
-                // This is a safe conversion since the difference must be less
-                // than BUFFER_SIZE in this branch.
-                (self.bytes_per_split - bytes_consumed) as usize
-            };
-            let bytes_read = reader
-                .read(&mut buffer[0..bytes_desired])
-                .unwrap_or_else(|_| crash!(1, "error reading bytes from input file"));
-            // If we ever read 0 bytes then we know we've hit EOF.
-            if bytes_read == 0 {
-                return bytes_consumed;
+/// Write a certain number of bytes to one file, then move on to another one.
+///
+/// This struct maintains an underlying writer representing the
+/// current chunk of the output. If a call to [`write`] would cause
+/// the underlying writer to write more than the allowed number of
+/// bytes, a new writer is created and the excess bytes are written to
+/// that one instead. As many new underlying writers are created as
+/// needed to write all the bytes in the input buffer.
+struct ByteChunkWriter<'a> {
+    /// Parameters for creating the underlying writer for each new chunk.
+    settings: &'a Settings,
+
+    /// The maximum number of bytes allowed for a single chunk of output.
+    chunk_size: u64,
+
+    /// Running total of number of chunks that have been completed.
+    num_chunks_written: u64,
+
+    /// Remaining capacity in number of bytes in the current chunk.
+    ///
+    /// This number starts at `chunk_size` and decreases as bytes are
+    /// written. Once it reaches zero, a writer for a new chunk is
+    /// initialized and this number gets reset to `chunk_size`.
+    num_bytes_remaining_in_current_chunk: u64,
+
+    /// The underlying writer for the current chunk.
+    ///
+    /// Once the number of bytes written to this writer exceeds
+    /// `chunk_size`, a new writer is initialized and assigned to this
+    /// field.
+    inner: BufWriter<Box<dyn Write>>,
+
+    /// Iterator that yields filenames for each chunk.
+    filename_iterator: FilenameIterator<'a>,
+}
+
+impl<'a> ByteChunkWriter<'a> {
+    fn new(chunk_size: u64, settings: &'a Settings) -> Option<ByteChunkWriter<'a>> {
+        let mut filename_iterator = FilenameIterator::new(
+            &settings.prefix,
+            &settings.additional_suffix,
+            settings.suffix_length,
+            settings.suffix_type,
+        );
+        let filename = filename_iterator.next()?;
+        if settings.verbose {
+            println!("creating file {}", filename.quote());
+        }
+        let inner = platform::instantiate_current_writer(&settings.filter, &filename);
+        Some(ByteChunkWriter {
+            settings,
+            chunk_size,
+            num_bytes_remaining_in_current_chunk: chunk_size,
+            num_chunks_written: 0,
+            inner,
+            filename_iterator,
+        })
+    }
+}
+
+impl<'a> Write for ByteChunkWriter<'a> {
+    fn write(&mut self, mut buf: &[u8]) -> std::io::Result<usize> {
+        // If the length of `buf` exceeds the number of bytes remaining
+        // in the current chunk, we will need to write to multiple
+        // different underlying writers. In that case, each iteration of
+        // this loop writes to the underlying writer that corresponds to
+        // the current chunk number.
+        let mut carryover_bytes_written: usize = 0;
+        loop {
+            if buf.is_empty() {
+                return Ok(carryover_bytes_written);
             }
 
-            writer
-                .write_all(&buffer[0..bytes_read])
-                .unwrap_or_else(|_| crash!(1, "error writing bytes to output file"));
+            // If the capacity of this chunk is greater than the number of
+            // bytes in `buf`, then write all the bytes in `buf`. Otherwise,
+            // write enough bytes to fill the current chunk, then increment
+            // the chunk number and repeat.
+            let n = buf.len();
+            if (n as u64) < self.num_bytes_remaining_in_current_chunk {
+                let num_bytes_written = self.inner.write(buf)?;
+                self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64;
+                return Ok(carryover_bytes_written + num_bytes_written);
+            } else {
+                // Write enough bytes to fill the current chunk.
+                //
+                // Conversion to usize is safe because we checked that
+                // self.num_bytes_remaining_in_current_chunk is lower than
+                // n, which is already usize.
+                let i = self.num_bytes_remaining_in_current_chunk as usize;
+                let num_bytes_written = self.inner.write(&buf[..i])?;
 
-            bytes_consumed += bytes_read as u128;
+                // It's possible that the underlying writer did not
+                // write all the bytes.
+                if num_bytes_written < i {
+                    self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64;
+                    return Ok(carryover_bytes_written + num_bytes_written);
+                } else {
+                    // Move the window to look at only the remaining bytes.
+                    buf = &buf[i..];
+
+                    // Increment the chunk number, reset the number of
+                    // bytes remaining, and instantiate the new
+                    // underlying writer.
+                    self.num_chunks_written += 1;
+                    self.num_bytes_remaining_in_current_chunk = self.chunk_size;
+
+                    // Remember for the next iteration that we wrote these bytes.
+                    carryover_bytes_written += num_bytes_written;
+
+                    // Only create the writer for the next chunk if
+                    // there are any remaining bytes to write. This
+                    // check prevents us from creating a new empty
+                    // file.
+                    if !buf.is_empty() {
+                        let filename = self.filename_iterator.next().ok_or_else(|| {
+                            std::io::Error::new(ErrorKind::Other, "output file suffixes exhausted")
+                        })?;
+                        if self.settings.verbose {
+                            println!("creating file {}", filename.quote());
+                        }
+                        self.inner =
+                            platform::instantiate_current_writer(&self.settings.filter, &filename);
+                    }
+                }
+            }
+        }
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+/// Write a certain number of lines to one file, then move on to another one.
+///
+/// This struct maintains an underlying writer representing the
+/// current chunk of the output. If a call to [`write`] would cause
+/// the underlying writer to write more than the allowed number of
+/// lines, a new writer is created and the excess lines are written to
+/// that one instead. As many new underlying writers are created as
+/// needed to write all the lines in the input buffer.
+struct LineChunkWriter<'a> {
+    /// Parameters for creating the underlying writer for each new chunk.
+    settings: &'a Settings,
+
+    /// The maximum number of lines allowed for a single chunk of output.
+    chunk_size: u64,
+
+    /// Running total of number of chunks that have been completed.
+    num_chunks_written: u64,
+
+    /// Remaining capacity in number of lines in the current chunk.
+    ///
+    /// This number starts at `chunk_size` and decreases as lines are
+    /// written. Once it reaches zero, a writer for a new chunk is
+    /// initialized and this number gets reset to `chunk_size`.
+    num_lines_remaining_in_current_chunk: u64,
+
+    /// The underlying writer for the current chunk.
+    ///
+    /// Once the number of lines written to this writer exceeds
+    /// `chunk_size`, a new writer is initialized and assigned to this
+    /// field.
+    inner: BufWriter<Box<dyn Write>>,
+
+    /// Iterator that yields filenames for each chunk.
+    filename_iterator: FilenameIterator<'a>,
+}
+
+impl<'a> LineChunkWriter<'a> {
+    fn new(chunk_size: u64, settings: &'a Settings) -> Option<LineChunkWriter<'a>> {
+        let mut filename_iterator = FilenameIterator::new(
+            &settings.prefix,
+            &settings.additional_suffix,
+            settings.suffix_length,
+            settings.suffix_type,
+        );
+        let filename = filename_iterator.next()?;
+        if settings.verbose {
+            println!("creating file {}", filename.quote());
+        }
+        let inner = platform::instantiate_current_writer(&settings.filter, &filename);
+        Some(LineChunkWriter {
+            settings,
+            chunk_size,
+            num_lines_remaining_in_current_chunk: chunk_size,
+            num_chunks_written: 0,
+            inner,
+            filename_iterator,
+        })
+    }
+}
+
+impl<'a> Write for LineChunkWriter<'a> {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        // If the number of lines in `buf` exceeds the number of lines
+        // remaining in the current chunk, we will need to write to
+        // multiple different underlying writers. In that case, each
+        // iteration of this loop writes to the underlying writer that
+        // corresponds to the current chunk number.
+        let mut prev = 0;
+        let mut total_bytes_written = 0;
+        for i in memchr::memchr_iter(b'\n', buf) {
+            // If we have exceeded the number of lines to write in the
+            // current chunk, then start a new chunk and its
+            // corresponding writer.
+            if self.num_lines_remaining_in_current_chunk == 0 {
+                self.num_chunks_written += 1;
+                let filename = self.filename_iterator.next().ok_or_else(|| {
+                    std::io::Error::new(ErrorKind::Other, "output file suffixes exhausted")
+                })?;
+                if self.settings.verbose {
+                    println!("creating file {}", filename.quote());
+                }
+                self.inner = platform::instantiate_current_writer(&self.settings.filter, &filename);
+                self.num_lines_remaining_in_current_chunk = self.chunk_size;
+            }
+
+            // Write the line, starting from *after* the previous
+            // newline character and ending *after* the current
+            // newline character.
+            let n = self.inner.write(&buf[prev..i + 1])?;
+            total_bytes_written += n;
+            prev = i + 1;
+            self.num_lines_remaining_in_current_chunk -= 1;
         }
 
-        bytes_consumed
+        let n = self.inner.write(&buf[prev..buf.len()])?;
+        total_bytes_written += n;
+        Ok(total_bytes_written)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.inner.flush()
     }
 }
 
-// (1, 3) -> "aab"
-#[allow(clippy::many_single_char_names)]
-fn str_prefix(i: usize, width: usize) -> String {
-    let mut c = "".to_owned();
-    let mut n = i;
-    let mut w = width;
-    while w > 0 {
-        w -= 1;
-        let div = 26usize.pow(w as u32);
-        let r = n / div;
-        n -= r * div;
-        c.push(char::from_u32((r as u32) + 97).unwrap());
-    }
-    c
+/// Write lines to each sequential output files, limited by bytes.
+///
+/// This struct maintains an underlying writer representing the
+/// current chunk of the output. On each call to [`write`], it writes
+/// as many lines as possible to the current chunk without exceeding
+/// the specified byte limit. If a single line has more bytes than the
+/// limit, then fill an entire single chunk with those bytes and
+/// handle the remainder of the line as if it were its own distinct
+/// line. As many new underlying writers are created as needed to
+/// write all the data in the input buffer.
+struct LineBytesChunkWriter<'a> {
+    /// Parameters for creating the underlying writer for each new chunk.
+    settings: &'a Settings,
+
+    /// The maximum number of bytes allowed for a single chunk of output.
+    chunk_size: u64,
+
+    /// Running total of number of chunks that have been completed.
+    num_chunks_written: usize,
+
+    /// Remaining capacity in number of bytes in the current chunk.
+    ///
+    /// This number starts at `chunk_size` and decreases as lines are
+    /// written. Once it reaches zero, a writer for a new chunk is
+    /// initialized and this number gets reset to `chunk_size`.
+    num_bytes_remaining_in_current_chunk: usize,
+
+    /// The underlying writer for the current chunk.
+    ///
+    /// Once the number of bytes written to this writer exceeds
+    /// `chunk_size`, a new writer is initialized and assigned to this
+    /// field.
+    inner: BufWriter<Box<dyn Write>>,
+
+    /// Iterator that yields filenames for each chunk.
+    filename_iterator: FilenameIterator<'a>,
 }
 
-// (1, 3) -> "001"
-#[allow(clippy::many_single_char_names)]
-fn num_prefix(i: usize, width: usize) -> String {
-    let mut c = "".to_owned();
-    let mut n = i;
-    let mut w = width;
-    while w > 0 {
-        w -= 1;
-        let div = 10usize.pow(w as u32);
-        let r = n / div;
-        n -= r * div;
-        c.push(char::from_digit(r as u32, 10).unwrap());
+impl<'a> LineBytesChunkWriter<'a> {
+    fn new(chunk_size: u64, settings: &'a Settings) -> Option<LineBytesChunkWriter<'a>> {
+        let mut filename_iterator = FilenameIterator::new(
+            &settings.prefix,
+            &settings.additional_suffix,
+            settings.suffix_length,
+            settings.suffix_type,
+        );
+        let filename = filename_iterator.next()?;
+        if settings.verbose {
+            println!("creating file {}", filename.quote());
+        }
+        let inner = platform::instantiate_current_writer(&settings.filter, &filename);
+        Some(LineBytesChunkWriter {
+            settings,
+            chunk_size,
+            num_bytes_remaining_in_current_chunk: chunk_size.try_into().unwrap(),
+            num_chunks_written: 0,
+            inner,
+            filename_iterator,
+        })
     }
-    c
 }
 
-fn split(settings: &Settings) -> i32 {
+impl<'a> Write for LineBytesChunkWriter<'a> {
+    /// Write as many lines to a chunk as possible without
+    /// exceeding the byte limit. If a single line has more bytes
+    /// than the limit, then fill an entire single chunk with those
+    /// bytes and handle the remainder of the line as if it were
+    /// its own distinct line.
+    ///
+    /// For example: if the `chunk_size` is 8 and the input is:
+    ///
+    /// ```text
+    /// aaaaaaaaa\nbbbb\ncccc\ndd\nee\n
+    /// ```
+    ///
+    /// then the output gets broken into chunks like this:
+    ///
+    /// ```text
+    /// chunk 0    chunk 1    chunk 2    chunk 3
+    ///
+    /// 0            1             2
+    /// 01234567  89 01234   56789 012   345 6
+    /// |------|  |-------|  |--------|  |---|
+    /// aaaaaaaa  a\nbbbb\n  cccc\ndd\n  ee\n
+    /// ```
+    fn write(&mut self, mut buf: &[u8]) -> std::io::Result<usize> {
+        // The total number of bytes written during the loop below.
+        //
+        // It is necessary to keep this running total because we may
+        // be making multiple calls to `write()` on multiple different
+        // underlying writers and we want the final reported number of
+        // bytes written to reflect the total number of bytes written
+        // to all of the underlying writers.
+        let mut total_bytes_written = 0;
+
+        // Loop until we have written all bytes in the input buffer
+        // (or an IO error occurs).
+        loop {
+            // If the buffer is empty, then we are done writing.
+            if buf.is_empty() {
+                return Ok(total_bytes_written);
+            }
+
+            // If we have filled the current chunk with bytes, then
+            // start a new chunk and initialize its corresponding
+            // writer.
+            if self.num_bytes_remaining_in_current_chunk == 0 {
+                self.num_chunks_written += 1;
+                let filename = self.filename_iterator.next().ok_or_else(|| {
+                    std::io::Error::new(ErrorKind::Other, "output file suffixes exhausted")
+                })?;
+                if self.settings.verbose {
+                    println!("creating file {}", filename.quote());
+                }
+                self.inner = platform::instantiate_current_writer(&self.settings.filter, &filename);
+                self.num_bytes_remaining_in_current_chunk = self.chunk_size.try_into().unwrap();
+            }
+
+            // Find the first newline character in the buffer.
+            match memchr::memchr(b'\n', buf) {
+                // If there is no newline character and the buffer is
+                // not empty, then write as many bytes as we can and
+                // then move on to the next chunk if necessary.
+                None => {
+                    let end = self.num_bytes_remaining_in_current_chunk;
+                    let num_bytes_written = self.inner.write(&buf[..end.min(buf.len())])?;
+                    self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
+                    total_bytes_written += num_bytes_written;
+                    buf = &buf[num_bytes_written..];
+                }
+
+                // If there is a newline character and the line
+                // (including the newline character) will fit in the
+                // current chunk, then write the entire line and
+                // continue to the next iteration. (See chunk 1 in the
+                // example comment above.)
+                Some(i) if i < self.num_bytes_remaining_in_current_chunk => {
+                    let num_bytes_written = self.inner.write(&buf[..i + 1])?;
+                    self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
+                    total_bytes_written += num_bytes_written;
+                    buf = &buf[num_bytes_written..];
+                }
+
+                // If there is a newline character, the line
+                // (including the newline character) will not fit in
+                // the current chunk, *and* no other lines have been
+                // written to the current chunk, then write as many
+                // bytes as we can and continue to the next
+                // iteration. (See chunk 0 in the example comment
+                // above.)
+                Some(_)
+                    if self.num_bytes_remaining_in_current_chunk
+                        == self.chunk_size.try_into().unwrap() =>
+                {
+                    let end = self.num_bytes_remaining_in_current_chunk;
+                    let num_bytes_written = self.inner.write(&buf[..end])?;
+                    self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
+                    total_bytes_written += num_bytes_written;
+                    buf = &buf[num_bytes_written..];
+                }
+
+                // If there is a newline character, the line
+                // (including the newline character) will not fit in
+                // the current chunk, and at least one other line has
+                // been written to the current chunk, then signal to
+                // the next iteration that a new chunk needs to be
+                // created and continue to the next iteration of the
+                // loop to try writing the line there.
+                Some(_) => {
+                    self.num_bytes_remaining_in_current_chunk = 0;
+                }
+            }
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+/// 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.
+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 {
+        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.additional_suffix,
+        settings.suffix_length,
+        settings.suffix_type,
+    );
+
+    // 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 = platform::instantiate_current_writer(&settings.filter, filename.as_str());
+        writers.push(writer);
+    }
+
+    // Capture the result of the `std::io::copy()` calls to check for
+    // `BrokenPipe`.
+    let result: std::io::Result<()> = {
+        // 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) {
+            io::copy(&mut reader.by_ref().take(chunk_size), writer)?;
+        }
+
+        // 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));
+        io::copy(&mut reader.by_ref().take(last_chunk_size), &mut writers[i])?;
+
+        Ok(())
+    };
+    match result {
+        Ok(_) => Ok(()),
+        Err(e) if e.kind() == ErrorKind::BrokenPipe => Ok(()),
+        Err(e) => Err(uio_error!(e, "input/output error")),
+    }
+}
+
+/// Split a file into a specific number of chunks by line.
+///
+/// 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.
+///
+/// # See also
+///
+/// * [`kth_chunk_by_line`], which splits its input in the same way,
+///   but writes only one specified chunk to stdout.
+fn split_into_n_chunks_by_line<R>(
+    settings: &Settings,
+    reader: &mut R,
+    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).unwrap();
+    let num_bytes = metadata.len();
+    let chunk_size = (num_bytes / (num_chunks as u64)) as usize;
+
+    // This object is responsible for creating the filename for each chunk.
+    let mut filename_iterator = FilenameIterator::new(
+        &settings.prefix,
+        &settings.additional_suffix,
+        settings.suffix_length,
+        settings.suffix_type,
+    );
+
+    // 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 = platform::instantiate_current_writer(&settings.filter, filename.as_str());
+        writers.push(writer);
+    }
+
+    let mut num_bytes_remaining_in_current_chunk = chunk_size;
+    let mut i = 0;
+    for line_result in reader.lines() {
+        let line = line_result.unwrap();
+        let maybe_writer = writers.get_mut(i);
+        let writer = maybe_writer.unwrap();
+        let bytes = line.as_bytes();
+        writer.write_all(bytes)?;
+        writer.write_all(b"\n")?;
+
+        // Add one byte for the newline 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;
+        }
+    }
+
+    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.
+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).unwrap();
+    let num_bytes = metadata.len();
+    let chunk_size = (num_bytes / (num_chunks as u64)) 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 = 0;
+    for line_result in reader.lines() {
+        let line = line_result?;
+        let bytes = line.as_bytes();
+        if i == chunk_number {
+            writer.write_all(bytes)?;
+            writer.write_all(b"\n")?;
+        }
+
+        // Add one byte for the newline 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;
+        }
+
+        if i > chunk_number {
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+fn split(settings: &Settings) -> UResult<()> {
     let mut reader = BufReader::new(if settings.input == "-" {
         Box::new(stdin()) as Box<dyn Read>
     } else {
-        let r = File::open(Path::new(&settings.input)).unwrap_or_else(|_| {
-            crash!(
-                1,
+        let r = File::open(Path::new(&settings.input)).map_err_context(|| {
+            format!(
                 "cannot open {} for reading: No such file or directory",
                 settings.input.quote()
             )
-        });
+        })?;
         Box::new(r) as Box<dyn Read>
     });
 
-    let mut splitter: Box<dyn Splitter> = match settings.strategy.as_str() {
-        s if s == OPT_LINES => Box::new(LineSplitter::new(settings)),
-        s if (s == OPT_BYTES || s == OPT_LINE_BYTES) => Box::new(ByteSplitter::new(settings)),
-        a => crash!(1, "strategy {} not supported", a.quote()),
-    };
-
-    let mut fileno = 0;
-    loop {
-        // Get a new part file set up, and construct `writer` for it.
-        let mut filename = settings.prefix.clone();
-        filename.push_str(
-            if settings.numeric_suffix {
-                num_prefix(fileno, settings.suffix_length)
-            } else {
-                str_prefix(fileno, settings.suffix_length)
-            }
-            .as_ref(),
-        );
-        filename.push_str(settings.additional_suffix.as_ref());
-        let mut writer = platform::instantiate_current_writer(&settings.filter, filename.as_str());
-
-        let bytes_consumed = splitter.consume(&mut reader, &mut writer);
-        writer
-            .flush()
-            .unwrap_or_else(|e| crash!(1, "error flushing to output file: {}", e));
-
-        // If we didn't write anything we should clean up the empty file, and
-        // break from the loop.
-        if bytes_consumed == 0 {
-            // The output file is only ever created if --filter isn't used.
-            // Complicated, I know...
-            if settings.filter.is_none() {
-                remove_file(filename)
-                    .unwrap_or_else(|e| crash!(1, "error removing empty file: {}", e));
-            }
-            break;
+    match settings.strategy {
+        Strategy::Number(NumberType::Bytes(num_chunks)) => {
+            split_into_n_chunks_by_byte(settings, &mut reader, num_chunks)
+        }
+        Strategy::Number(NumberType::Lines(num_chunks)) => {
+            split_into_n_chunks_by_line(settings, &mut reader, num_chunks)
+        }
+        Strategy::Number(NumberType::KthLines(chunk_number, num_chunks)) => {
+            // The chunk number is given as a 1-indexed number, but it
+            // is a little easier to deal with a 0-indexed number.
+            let chunk_number = chunk_number - 1;
+            kth_chunk_by_line(settings, &mut reader, chunk_number, num_chunks)
+        }
+        Strategy::Number(_) => Err(USimpleError::new(1, "-n mode not yet fully implemented")),
+        Strategy::Lines(chunk_size) => {
+            let mut writer = LineChunkWriter::new(chunk_size, settings)
+                .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
+            match std::io::copy(&mut reader, &mut writer) {
+                Ok(_) => Ok(()),
+                Err(e) => match e.kind() {
+                    // TODO Since the writer object controls the creation of
+                    // new files, we need to rely on the `std::io::Result`
+                    // returned by its `write()` method to communicate any
+                    // errors to this calling scope. If a new file cannot be
+                    // created because we have exceeded the number of
+                    // allowable filenames, we use `ErrorKind::Other` to
+                    // indicate that. A special error message needs to be
+                    // printed in that case.
+                    ErrorKind::Other => Err(USimpleError::new(1, "output file suffixes exhausted")),
+                    ErrorKind::BrokenPipe => Ok(()),
+                    _ => Err(uio_error!(e, "input/output error")),
+                },
+            }
+        }
+        Strategy::Bytes(chunk_size) => {
+            let mut writer = ByteChunkWriter::new(chunk_size, settings)
+                .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
+            match std::io::copy(&mut reader, &mut writer) {
+                Ok(_) => Ok(()),
+                Err(e) => match e.kind() {
+                    // TODO Since the writer object controls the creation of
+                    // new files, we need to rely on the `std::io::Result`
+                    // returned by its `write()` method to communicate any
+                    // errors to this calling scope. If a new file cannot be
+                    // created because we have exceeded the number of
+                    // allowable filenames, we use `ErrorKind::Other` to
+                    // indicate that. A special error message needs to be
+                    // printed in that case.
+                    ErrorKind::Other => Err(USimpleError::new(1, "output file suffixes exhausted")),
+                    ErrorKind::BrokenPipe => Ok(()),
+                    _ => Err(uio_error!(e, "input/output error")),
+                },
+            }
+        }
+        Strategy::LineBytes(chunk_size) => {
+            let mut writer = LineBytesChunkWriter::new(chunk_size, settings)
+                .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
+            match std::io::copy(&mut reader, &mut writer) {
+                Ok(_) => Ok(()),
+                Err(e) => match e.kind() {
+                    // TODO Since the writer object controls the creation of
+                    // new files, we need to rely on the `std::io::Result`
+                    // returned by its `write()` method to communicate any
+                    // errors to this calling scope. If a new file cannot be
+                    // created because we have exceeded the number of
+                    // allowable filenames, we use `ErrorKind::Other` to
+                    // indicate that. A special error message needs to be
+                    // printed in that case.
+                    ErrorKind::Other => Err(USimpleError::new(1, "output file suffixes exhausted")),
+                    ErrorKind::BrokenPipe => Ok(()),
+                    _ => Err(uio_error!(e, "input/output error")),
+                },
+            }
         }
-
-        fileno += 1;
     }
-    0
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::NumberType;
+    use crate::NumberTypeError;
+
+    #[test]
+    fn test_number_type_from() {
+        assert_eq!(NumberType::from("123").unwrap(), NumberType::Bytes(123));
+        assert_eq!(NumberType::from("l/123").unwrap(), NumberType::Lines(123));
+        assert_eq!(
+            NumberType::from("l/123/456").unwrap(),
+            NumberType::KthLines(123, 456)
+        );
+        assert_eq!(
+            NumberType::from("r/123").unwrap(),
+            NumberType::RoundRobin(123)
+        );
+        assert_eq!(
+            NumberType::from("r/123/456").unwrap(),
+            NumberType::KthRoundRobin(123, 456)
+        );
+    }
+
+    #[test]
+    fn test_number_type_from_error() {
+        assert_eq!(
+            NumberType::from("xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("l/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("l/123/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("l/abc/456").unwrap_err(),
+            NumberTypeError::ChunkNumber("abc".to_string())
+        );
+        // In GNU split, the number of chunks get precedence:
+        //
+        //     $ split -n l/abc/xyz
+        //     split: invalid number of chunks: ‘xyz’
+        //
+        assert_eq!(
+            NumberType::from("l/abc/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("r/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("r/123/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("r/abc/456").unwrap_err(),
+            NumberTypeError::ChunkNumber("abc".to_string())
+        );
+        // In GNU split, the number of chunks get precedence:
+        //
+        //     $ split -n r/abc/xyz
+        //     split: invalid number of chunks: ‘xyz’
+        //
+        assert_eq!(
+            NumberType::from("r/abc/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+    }
+
+    #[test]
+    fn test_number_type_num_chunks() {
+        assert_eq!(NumberType::from("123").unwrap().num_chunks(), 123);
+        assert_eq!(NumberType::from("l/123").unwrap().num_chunks(), 123);
+        assert_eq!(NumberType::from("l/123/456").unwrap().num_chunks(), 456);
+        assert_eq!(NumberType::from("r/123").unwrap().num_chunks(), 123);
+        assert_eq!(NumberType::from("r/123/456").unwrap().num_chunks(), 456);
+    }
 }
diff --git a/src/uu/stat/Cargo.toml b/src/uu/stat/Cargo.toml
index a1f168b14..23087e2df 100644
--- a/src/uu/stat/Cargo.toml
+++ b/src/uu/stat/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_stat"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stat ~ (uutils) display FILE status"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/stat"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/stat"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/stat.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries", "libc", "fs", "fsext"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries", "libc", "fs", "fsext"] }
 
 [[bin]]
 name = "stat"
diff --git a/src/uu/stat/LICENSE b/src/uu/stat/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/stat/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/stat/src/main.rs b/src/uu/stat/src/main.rs
index 839eff7de..3607ac4ae 100644
--- a/src/uu/stat/src/main.rs
+++ b/src/uu/stat/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_stat);
+uucore::bin!(uu_stat);
diff --git a/src/uu/stat/src/stat.rs b/src/uu/stat/src/stat.rs
index fd4a6443d..7d1073020 100644
--- a/src/uu/stat/src/stat.rs
+++ b/src/uu/stat/src/stat.rs
@@ -8,14 +8,15 @@
 #[macro_use]
 extern crate uucore;
 use uucore::display::Quotable;
-use uucore::entries;
+use uucore::error::{UResult, USimpleError};
 use uucore::fs::display_permissions;
 use uucore::fsext::{
     pretty_filetype, pretty_fstype, pretty_time, read_fs_list, statfs, BirthTime, FsMeta,
 };
 use uucore::libc::mode_t;
+use uucore::{entries, format_usage};
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use std::borrow::Cow;
 use std::convert::AsRef;
 use std::os::unix::fs::{FileTypeExt, MetadataExt};
@@ -25,7 +26,10 @@ use std::{cmp, fs, iter};
 macro_rules! check_bound {
     ($str: ident, $bound:expr, $beg: expr, $end: expr) => {
         if $end >= $bound {
-            return Err(format!("{}: invalid directive", $str[$beg..$end].quote()));
+            return Err(USimpleError::new(
+                1,
+                format!("{}: invalid directive", $str[$beg..$end].quote()),
+            ));
         }
     };
 }
@@ -83,6 +87,7 @@ macro_rules! print_adjusted {
 }
 
 static ABOUT: &str = "Display file or file system status.";
+const USAGE: &str = "{} [OPTION]... FILE...";
 
 pub mod options {
     pub static DEREFERENCE: &str = "dereference";
@@ -189,11 +194,19 @@ impl ScanUtil for str {
 }
 
 pub fn group_num(s: &str) -> Cow<str> {
-    assert!(s.chars().all(char::is_numeric));
+    let is_negative = s.starts_with('-');
+    assert!(is_negative || s.chars().take(1).all(|c| c.is_digit(10)));
+    assert!(s.chars().skip(1).all(|c| c.is_digit(10)));
     if s.len() < 4 {
         return s.into();
     }
     let mut res = String::with_capacity((s.len() - 1) / 3);
+    let s = if is_negative {
+        res.push('-');
+        &s[1..]
+    } else {
+        s
+    };
     let mut alone = (s.len() - 1) % 3 + 1;
     res.push_str(&s[..alone]);
     while alone != s.len() {
@@ -215,7 +228,7 @@ pub struct Stater {
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn print_it(arg: &str, output_type: OutputType, flag: u8, width: usize, precision: i32) {
+fn print_it(arg: &str, output_type: &OutputType, flag: u8, width: usize, precision: i32) {
     // If the precision is given as just '.', the precision is taken to be zero.
     // A negative precision is taken as if the precision were omitted.
     // This gives the minimum number of digits to appear for d, i, o, u, x, and X conversions,
@@ -246,7 +259,7 @@ fn print_it(arg: &str, output_type: OutputType, flag: u8, width: usize, precisio
     // By default, a sign  is  used only for negative numbers.
     // A + overrides a space if both are used.
 
-    if output_type == OutputType::Unknown {
+    if output_type == &OutputType::Unknown {
         return print!("?");
     }
 
@@ -332,7 +345,7 @@ fn print_it(arg: &str, output_type: OutputType, flag: u8, width: usize, precisio
 }
 
 impl Stater {
-    pub fn generate_tokens(format_str: &str, use_printf: bool) -> Result<Vec<Token>, String> {
+    pub fn generate_tokens(format_str: &str, use_printf: bool) -> UResult<Vec<Token>> {
         let mut tokens = Vec::new();
         let bound = format_str.len();
         let chars = format_str.chars().collect::<Vec<char>>();
@@ -402,7 +415,7 @@ impl Stater {
                         flag,
                         precision,
                         format: chars[i],
-                    })
+                    });
                 }
                 '\\' => {
                     if !use_printf {
@@ -457,7 +470,7 @@ impl Stater {
         Ok(tokens)
     }
 
-    fn new(matches: ArgMatches) -> Result<Stater, String> {
+    fn new(matches: &ArgMatches) -> UResult<Self> {
         let files: Vec<String> = matches
             .values_of(ARG_FILES)
             .map(|v| v.map(ToString::to_string).collect())
@@ -476,14 +489,12 @@ impl Stater {
         let show_fs = matches.is_present(options::FILE_SYSTEM);
 
         let default_tokens = if format_str.is_empty() {
-            Stater::generate_tokens(&Stater::default_format(show_fs, terse, false), use_printf)
-                .unwrap()
+            Self::generate_tokens(&Self::default_format(show_fs, terse, false), use_printf)?
         } else {
-            Stater::generate_tokens(format_str, use_printf)?
+            Self::generate_tokens(format_str, use_printf)?
         };
         let default_dev_tokens =
-            Stater::generate_tokens(&Stater::default_format(show_fs, terse, true), use_printf)
-                .unwrap();
+            Self::generate_tokens(&Self::default_format(show_fs, terse, true), use_printf)?;
 
         let mount_list = if show_fs {
             // mount points aren't displayed when showing filesystem information
@@ -499,7 +510,7 @@ impl Stater {
             Some(mount_list)
         };
 
-        Ok(Stater {
+        Ok(Self {
             follow: matches.is_present(options::DEREFERENCE),
             show_fs,
             from_user: !format_str.is_empty(),
@@ -741,7 +752,7 @@ impl Stater {
                                         output_type = OutputType::Unknown;
                                     }
                                 }
-                                print_it(&arg, output_type, flag, width, precision);
+                                print_it(&arg, &output_type, flag, width, precision);
                             }
                         }
                     }
@@ -834,7 +845,7 @@ impl Stater {
                                     }
                                 }
 
-                                print_it(&arg, output_type, flag, width, precision);
+                                print_it(&arg, &output_type, flag, width, precision);
                             }
                         }
                     }
@@ -883,10 +894,6 @@ impl Stater {
     }
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... FILE...", uucore::execution_phrase())
-}
-
 fn get_long_usage() -> String {
     String::from(
         "
@@ -945,49 +952,48 @@ for details about the options it supports.
     )
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let long_usage = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&long_usage[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&long_usage[..]).get_matches_from(args);
 
-    match Stater::new(matches) {
-        Ok(stater) => stater.exec(),
-        Err(e) => {
-            show_error!("{}", e);
-            1
-        }
+    let stater = Stater::new(&matches)?;
+    let exit_status = stater.exec();
+    if exit_status == 0 {
+        Ok(())
+    } else {
+        Err(exit_status.into())
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::DEREFERENCE)
-                .short("L")
+            Arg::new(options::DEREFERENCE)
+                .short('L')
                 .long(options::DEREFERENCE)
                 .help("follow links"),
         )
         .arg(
-            Arg::with_name(options::FILE_SYSTEM)
-                .short("f")
+            Arg::new(options::FILE_SYSTEM)
+                .short('f')
                 .long(options::FILE_SYSTEM)
                 .help("display file system status instead of file status"),
         )
         .arg(
-            Arg::with_name(options::TERSE)
-                .short("t")
+            Arg::new(options::TERSE)
+                .short('t')
                 .long(options::TERSE)
                 .help("print the information in terse form"),
         )
         .arg(
-            Arg::with_name(options::FORMAT)
-                .short("c")
+            Arg::new(options::FORMAT)
+                .short('c')
                 .long(options::FORMAT)
                 .help(
                     "use the specified FORMAT instead of the default;
@@ -996,7 +1002,7 @@ pub fn uu_app() -> App<'static, 'static> {
                 .value_name("FORMAT"),
         )
         .arg(
-            Arg::with_name(options::PRINTF)
+            Arg::new(options::PRINTF)
                 .long(options::PRINTF)
                 .value_name("FORMAT")
                 .help(
@@ -1006,8 +1012,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(ARG_FILES)
-                .multiple(true)
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .min_values(1),
         )
diff --git a/src/uu/stdbuf/Cargo.toml b/src/uu/stdbuf/Cargo.toml
index 45863cd0c..98cdadf9f 100644
--- a/src/uu/stdbuf/Cargo.toml
+++ b/src/uu/stdbuf/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_stdbuf"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stdbuf ~ (uutils) run COMMAND with modified standard stream buffering"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/stdbuf"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/stdbuf"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,13 +15,12 @@ edition = "2018"
 path = "src/stdbuf.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-tempfile = "3.1"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+tempfile = "3"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [build-dependencies]
-libstdbuf = { version="0.0.8", package="uu_stdbuf_libstdbuf", path="src/libstdbuf" }
+libstdbuf = { version="0.0.13", package="uu_stdbuf_libstdbuf", path="src/libstdbuf" }
 
 [[bin]]
 name = "stdbuf"
diff --git a/src/uu/stdbuf/LICENSE b/src/uu/stdbuf/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/stdbuf/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/stdbuf/build.rs b/src/uu/stdbuf/build.rs
index b14d503cf..9d36f20f4 100644
--- a/src/uu/stdbuf/build.rs
+++ b/src/uu/stdbuf/build.rs
@@ -20,17 +20,38 @@ mod platform {
 }
 
 fn main() {
-    let manifest_dir = env::var("CARGO_MANIFEST_DIR").expect("Could not find manifest dir");
-    let profile = env::var("PROFILE").expect("Could not determine profile");
-
     let out_dir = env::var("OUT_DIR").unwrap();
-    let libstdbuf = format!(
-        "{}/../../../{}/{}/deps/liblibstdbuf{}",
-        manifest_dir,
-        env::var("CARGO_TARGET_DIR").unwrap_or_else(|_| "target".to_string()),
-        profile,
-        platform::DYLIB_EXT
-    );
+    let mut target_dir = Path::new(&out_dir);
 
-    fs::copy(libstdbuf, Path::new(&out_dir).join("libstdbuf.so")).unwrap();
+    // Depending on how this is util is built, the directory structure. This seems to work for now.
+    // Here are three cases to test when changing this:
+    // - cargo run
+    // - cross run
+    // - cargo install --git
+    // - cargo publish --dry-run
+    let mut name = target_dir.file_name().unwrap().to_string_lossy();
+    while name != "target" && !name.starts_with("cargo-install") {
+        target_dir = target_dir.parent().unwrap();
+        name = target_dir.file_name().unwrap().to_string_lossy();
+    }
+    let mut dir = target_dir.to_path_buf();
+    dir.push(env::var("PROFILE").unwrap());
+    dir.push("deps");
+    let mut path = None;
+
+    // When running cargo publish, cargo appends hashes to the filenames of the compiled artifacts.
+    // Therefore, it won't work to just get liblibstdbuf.so. Instead, we look for files with the
+    // glob pattern "liblibstdbuf*.so" (i.e. starts with liblibstdbuf and ends with the extension).
+    for entry in fs::read_dir(dir).unwrap().flatten() {
+        let name = entry.file_name();
+        let name = name.to_string_lossy();
+        if name.starts_with("liblibstdbuf") && name.ends_with(platform::DYLIB_EXT) {
+            path = Some(entry.path());
+        }
+    }
+    fs::copy(
+        path.expect("liblibstdbuf was not found"),
+        Path::new(&out_dir).join("libstdbuf.so"),
+    )
+    .unwrap();
 }
diff --git a/src/uu/stdbuf/src/libstdbuf/Cargo.toml b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
index 069a2ae11..72c6b3e03 100644
--- a/src/uu/stdbuf/src/libstdbuf/Cargo.toml
+++ b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "stdbuf/libstdbuf ~ (uutils); dynamic library required for stdbuf"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/stdbuf"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/stdbuf"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -19,8 +19,7 @@ crate-type = ["cdylib", "rlib"] # XXX: note: the rlib is just to prevent Cargo f
 [dependencies]
 cpp = "0.5"
 libc = "0.2"
-uucore = { version=">=0.0.10", package="uucore", path="../../../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../../../uucore" }
 
 [build-dependencies]
 cpp_build = "0.4"
diff --git a/src/uu/stdbuf/src/main.rs b/src/uu/stdbuf/src/main.rs
index 1989a3b8d..cf6a2408a 100644
--- a/src/uu/stdbuf/src/main.rs
+++ b/src/uu/stdbuf/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_stdbuf);
+uucore::bin!(uu_stdbuf);
diff --git a/src/uu/stdbuf/src/stdbuf.rs b/src/uu/stdbuf/src/stdbuf.rs
index 77d80f777..2eedb038b 100644
--- a/src/uu/stdbuf/src/stdbuf.rs
+++ b/src/uu/stdbuf/src/stdbuf.rs
@@ -10,21 +10,23 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, AppSettings, Arg, ArgMatches};
-use std::convert::TryFrom;
+use clap::{crate_version, Arg, ArgMatches, Command};
+use std::convert::{TryFrom, TryInto};
 use std::fs::File;
 use std::io::{self, Write};
 use std::os::unix::process::ExitStatusExt;
 use std::path::PathBuf;
-use std::process::Command;
+use std::process;
 use tempfile::tempdir;
 use tempfile::TempDir;
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::parse_size::parse_size;
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str =
     "Run COMMAND, with modified buffering operations for its standard streams.\n\n\
      Mandatory arguments to long options are mandatory for short options too.";
+const USAGE: &str = "{} OPTION... COMMAND";
 static LONG_HELP: &str = "If MODE is 'L' the corresponding stream will be line buffered.\n\
      This option is invalid with standard input.\n\n\
      If MODE is '0' the corresponding stream will be unbuffered.\n\n\
@@ -39,18 +41,14 @@ static LONG_HELP: &str = "If MODE is 'L' the corresponding stream will be line b
 
 mod options {
     pub const INPUT: &str = "input";
-    pub const INPUT_SHORT: &str = "i";
+    pub const INPUT_SHORT: char = 'i';
     pub const OUTPUT: &str = "output";
-    pub const OUTPUT_SHORT: &str = "o";
+    pub const OUTPUT_SHORT: char = 'o';
     pub const ERROR: &str = "error";
-    pub const ERROR_SHORT: &str = "e";
+    pub const ERROR_SHORT: char = 'e';
     pub const COMMAND: &str = "command";
 }
 
-fn usage() -> String {
-    format!("{0} OPTION... COMMAND", uucore::execution_phrase())
-}
-
 const STDBUF_INJECT: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/libstdbuf.so"));
 
 enum BufferType {
@@ -65,11 +63,11 @@ struct ProgramOptions {
     stderr: BufferType,
 }
 
-impl<'a> TryFrom<&ArgMatches<'a>> for ProgramOptions {
+impl<'a> TryFrom<&ArgMatches> for ProgramOptions {
     type Error = ProgramOptionsError;
 
     fn try_from(matches: &ArgMatches) -> Result<Self, Self::Error> {
-        Ok(ProgramOptions {
+        Ok(Self {
             stdin: check_option(matches, options::INPUT)?,
             stdout: check_option(matches, options::OUTPUT)?,
             stderr: check_option(matches, options::ERROR)?,
@@ -119,14 +117,21 @@ fn check_option(matches: &ArgMatches, name: &str) -> Result<BufferType, ProgramO
             }
             x => parse_size(x).map_or_else(
                 |e| crash!(125, "invalid mode {}", e),
-                |m| Ok(BufferType::Size(m)),
+                |m| {
+                    Ok(BufferType::Size(m.try_into().map_err(|_| {
+                        ProgramOptionsError(format!(
+                            "invalid mode '{}': Value too large for defined data type",
+                            x
+                        ))
+                    })?))
+                },
             ),
         },
         None => Ok(BufferType::Default),
     }
 }
 
-fn set_command_env(command: &mut Command, buffer_name: &str, buffer_type: BufferType) {
+fn set_command_env(command: &mut process::Command, buffer_name: &str, buffer_type: &BufferType) {
     match buffer_type {
         BufferType::Size(m) => {
             command.env(buffer_name, m.to_string());
@@ -148,83 +153,84 @@ fn get_preload_env(tmp_dir: &mut TempDir) -> io::Result<(String, PathBuf)> {
     Ok((preload.to_owned(), inject_path))
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
-    let usage = usage();
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
-    let options = ProgramOptions::try_from(&matches).unwrap_or_else(|e| {
-        crash!(
-            125,
-            "{}\nTry '{} --help' for more information.",
-            e.0,
-            uucore::execution_phrase()
-        )
-    });
+    let options = ProgramOptions::try_from(&matches).map_err(|e| UUsageError::new(125, e.0))?;
 
     let mut command_values = matches.values_of::<&str>(options::COMMAND).unwrap();
-    let mut command = Command::new(command_values.next().unwrap());
+    let mut command = process::Command::new(command_values.next().unwrap());
     let command_params: Vec<&str> = command_values.collect();
 
     let mut tmp_dir = tempdir().unwrap();
-    let (preload_env, libstdbuf) = crash_if_err!(1, get_preload_env(&mut tmp_dir));
+    let (preload_env, libstdbuf) = get_preload_env(&mut tmp_dir).map_err_context(String::new)?;
     command.env(preload_env, libstdbuf);
-    set_command_env(&mut command, "_STDBUF_I", options.stdin);
-    set_command_env(&mut command, "_STDBUF_O", options.stdout);
-    set_command_env(&mut command, "_STDBUF_E", options.stderr);
+    set_command_env(&mut command, "_STDBUF_I", &options.stdin);
+    set_command_env(&mut command, "_STDBUF_O", &options.stdout);
+    set_command_env(&mut command, "_STDBUF_E", &options.stderr);
     command.args(command_params);
 
-    let mut process = match command.spawn() {
-        Ok(p) => p,
-        Err(e) => crash!(1, "failed to execute process: {}", e),
-    };
-    match process.wait() {
-        Ok(status) => match status.code() {
-            Some(i) => i,
-            None => crash!(1, "process killed by signal {}", status.signal().unwrap()),
-        },
-        Err(e) => crash!(1, "{}", e),
+    let mut process = command
+        .spawn()
+        .map_err_context(|| "failed to execute process".to_string())?;
+    let status = process.wait().map_err_context(String::new)?;
+    match status.code() {
+        Some(i) => {
+            if i == 0 {
+                Ok(())
+            } else {
+                Err(i.into())
+            }
+        }
+        None => Err(USimpleError::new(
+            1,
+            format!("process killed by signal {}", status.signal().unwrap()),
+        )),
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
-        .setting(AppSettings::TrailingVarArg)
+        .override_usage(format_usage(USAGE))
+        .trailing_var_arg(true)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::INPUT)
+            Arg::new(options::INPUT)
                 .long(options::INPUT)
                 .short(options::INPUT_SHORT)
                 .help("adjust standard input stream buffering")
                 .value_name("MODE")
-                .required_unless_one(&[options::OUTPUT, options::ERROR]),
+                .required_unless_present_any(&[options::OUTPUT, options::ERROR]),
         )
         .arg(
-            Arg::with_name(options::OUTPUT)
+            Arg::new(options::OUTPUT)
                 .long(options::OUTPUT)
                 .short(options::OUTPUT_SHORT)
                 .help("adjust standard output stream buffering")
                 .value_name("MODE")
-                .required_unless_one(&[options::INPUT, options::ERROR]),
+                .required_unless_present_any(&[options::INPUT, options::ERROR]),
         )
         .arg(
-            Arg::with_name(options::ERROR)
+            Arg::new(options::ERROR)
                 .long(options::ERROR)
                 .short(options::ERROR_SHORT)
                 .help("adjust standard error stream buffering")
                 .value_name("MODE")
-                .required_unless_one(&[options::INPUT, options::OUTPUT]),
+                .required_unless_present_any(&[options::INPUT, options::OUTPUT]),
         )
         .arg(
-            Arg::with_name(options::COMMAND)
-                .multiple(true)
+            Arg::new(options::COMMAND)
+                .multiple_occurrences(true)
                 .takes_value(true)
-                .hidden(true)
+                .hide(true)
                 .required(true),
         )
 }
diff --git a/src/uu/sum/Cargo.toml b/src/uu/sum/Cargo.toml
index 273f9dff9..dab660574 100644
--- a/src/uu/sum/Cargo.toml
+++ b/src/uu/sum/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_sum"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sum ~ (uutils) display checksum and block counts for input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/sum"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sum"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/sum.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "sum"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/sum/LICENSE b/src/uu/sum/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/sum/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/sum/src/main.rs b/src/uu/sum/src/main.rs
index 85f4d0079..9d3c72e6f 100644
--- a/src/uu/sum/src/main.rs
+++ b/src/uu/sum/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_sum);
+uucore::bin!(uu_sum);
diff --git a/src/uu/sum/src/sum.rs b/src/uu/sum/src/sum.rs
index c58a1dcdc..501635910 100644
--- a/src/uu/sum/src/sum.rs
+++ b/src/uu/sum/src/sum.rs
@@ -10,17 +10,18 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::File;
-use std::io::{stdin, Read, Result};
+use std::io::{stdin, Read};
 use std::path::Path;
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static NAME: &str = "sum";
-static USAGE: &str =
-    "[OPTION]... [FILE]...\nWith no FILE, or when  FILE is -, read standard input.";
-static SUMMARY: &str = "Checksum and count the blocks in a file.";
+static USAGE: &str = "{} [OPTION]... [FILE]...";
+static SUMMARY: &str = "Checksum and count the blocks in a file.\n\
+                        With no FILE, or when  FILE is -, read standard input.";
 
 fn bsd_sum(mut reader: Box<dyn Read>) -> (usize, u16) {
     let mut buf = [0; 1024];
@@ -65,26 +66,25 @@ fn sysv_sum(mut reader: Box<dyn Read>) -> (usize, u16) {
     (blocks_read, ret as u16)
 }
 
-fn open(name: &str) -> Result<Box<dyn Read>> {
+fn open(name: &str) -> UResult<Box<dyn Read>> {
     match name {
         "-" => Ok(Box::new(stdin()) as Box<dyn Read>),
         _ => {
             let path = &Path::new(name);
             if path.is_dir() {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::InvalidInput,
-                    "Is a directory",
+                return Err(USimpleError::new(
+                    2,
+                    format!("{}: Is a directory", name.maybe_quote()),
                 ));
             };
             // Silent the warning as we want to the error message
-            #[allow(clippy::question_mark)]
             if path.metadata().is_err() {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::NotFound,
-                    "No such file or directory",
+                return Err(USimpleError::new(
+                    2,
+                    format!("{}: No such file or directory", name.maybe_quote()),
                 ));
             };
-            let f = File::open(path)?;
+            let f = File::open(path).map_err_context(String::new)?;
             Ok(Box::new(f) as Box<dyn Read>)
         }
     }
@@ -96,7 +96,8 @@ mod options {
     pub static SYSTEM_V_COMPATIBLE: &str = "sysv";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -116,13 +117,11 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         files.len() > 1
     };
 
-    let mut exit_code = 0;
     for file in &files {
         let reader = match open(file) {
             Ok(f) => f,
             Err(error) => {
-                show_error!("{}: {}", file.maybe_quote(), error);
-                exit_code = 2;
+                show!(error);
                 continue;
             }
         };
@@ -138,25 +137,29 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             println!("{} {}", sum, blocks);
         }
     }
-
-    exit_code
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
-        .arg(Arg::with_name(options::FILE).multiple(true).hidden(true))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BSD_COMPATIBLE)
-                .short(options::BSD_COMPATIBLE)
+            Arg::new(options::FILE)
+                .multiple_occurrences(true)
+                .hide(true),
+        )
+        .arg(
+            Arg::new(options::BSD_COMPATIBLE)
+                .short('r')
                 .help("use the BSD sum algorithm, use 1K blocks (default)"),
         )
         .arg(
-            Arg::with_name(options::SYSTEM_V_COMPATIBLE)
-                .short("s")
+            Arg::new(options::SYSTEM_V_COMPATIBLE)
+                .short('s')
                 .long(options::SYSTEM_V_COMPATIBLE)
                 .help("use System V sum algorithm, use 512 bytes blocks"),
         )
diff --git a/src/uu/sync/Cargo.toml b/src/uu/sync/Cargo.toml
index 4bf2c60b3..01400448a 100644
--- a/src/uu/sync/Cargo.toml
+++ b/src/uu/sync/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_sync"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "sync ~ (uutils) synchronize cache writes to storage"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/sync"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sync"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,12 +15,14 @@ edition = "2018"
 path = "src/sync.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["wide"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["wide"] }
 winapi = { version = "0.3", features = ["errhandlingapi", "fileapi", "handleapi", "std", "winbase", "winerror"] }
 
 [[bin]]
 name = "sync"
 path = "src/main.rs"
+
+[package.metadata.cargo-udeps.ignore]
+normal = ["uucore_procs", "winapi"]
diff --git a/src/uu/sync/LICENSE b/src/uu/sync/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/sync/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/sync/src/main.rs b/src/uu/sync/src/main.rs
index 9786fc371..54747b050 100644
--- a/src/uu/sync/src/main.rs
+++ b/src/uu/sync/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_sync);
+uucore::bin!(uu_sync);
diff --git a/src/uu/sync/src/sync.rs b/src/uu/sync/src/sync.rs
index d6a21f280..f9c18d500 100644
--- a/src/uu/sync/src/sync.rs
+++ b/src/uu/sync/src/sync.rs
@@ -9,16 +9,14 @@
 
 extern crate libc;
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::path::Path;
 use uucore::display::Quotable;
-
-static EXIT_ERR: i32 = 1;
+use uucore::error::{UResult, USimpleError};
+use uucore::format_usage;
 
 static ABOUT: &str = "Synchronize cached writes to persistent storage";
+const USAGE: &str = "{} [OPTION]... FILE...";
 pub mod options {
     pub static FILE_SYSTEM: &str = "file-system";
     pub static DATA: &str = "data";
@@ -72,6 +70,7 @@ mod platform {
     use std::mem;
     use std::os::windows::prelude::*;
     use std::path::Path;
+    use uucore::crash;
     use uucore::wide::{FromWide, ToWide};
 
     unsafe fn flush_volume(name: &str) {
@@ -160,14 +159,9 @@ mod platform {
     }
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... FILE...", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let files: Vec<String> = matches
         .values_of(ARG_FILES)
@@ -176,11 +170,10 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
 
     for f in &files {
         if !Path::new(&f).exists() {
-            crash!(
-                EXIT_ERR,
-                "cannot stat {}: No such file or directory",
-                f.quote()
-            );
+            return Err(USimpleError::new(
+                1,
+                format!("cannot stat {}: No such file or directory", f.quote()),
+            ));
         }
     }
 
@@ -194,28 +187,34 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     } else {
         sync();
     }
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::FILE_SYSTEM)
-                .short("f")
+            Arg::new(options::FILE_SYSTEM)
+                .short('f')
                 .long(options::FILE_SYSTEM)
                 .conflicts_with(options::DATA)
                 .help("sync the file systems that contain the files (Linux and Windows only)"),
         )
         .arg(
-            Arg::with_name(options::DATA)
-                .short("d")
+            Arg::new(options::DATA)
+                .short('d')
                 .long(options::DATA)
                 .conflicts_with(options::FILE_SYSTEM)
                 .help("sync only file data, no unneeded metadata (Linux only)"),
         )
-        .arg(Arg::with_name(ARG_FILES).multiple(true).takes_value(true))
+        .arg(
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
+                .takes_value(true),
+        )
 }
 
 fn sync() -> isize {
diff --git a/src/uu/tac/Cargo.toml b/src/uu/tac/Cargo.toml
index 6840d6bc3..b63790a9f 100644
--- a/src/uu/tac/Cargo.toml
+++ b/src/uu/tac/Cargo.toml
@@ -2,13 +2,13 @@
 
 [package]
 name = "uu_tac"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tac ~ (uutils) concatenate and display input lines in reverse order"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/tac"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tac"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -20,14 +20,9 @@ path = "src/tac.rs"
 memchr = "2"
 memmap2 = "0.5"
 regex = "1"
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "tac"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/tac/LICENSE b/src/uu/tac/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/tac/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/tac/src/error.rs b/src/uu/tac/src/error.rs
new file mode 100644
index 000000000..92b071cc4
--- /dev/null
+++ b/src/uu/tac/src/error.rs
@@ -0,0 +1,60 @@
+//  * 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.
+//! Errors returned by tac during processing of a file.
+use std::error::Error;
+use std::fmt::Display;
+
+use uucore::display::Quotable;
+use uucore::error::UError;
+
+#[derive(Debug)]
+pub enum TacError {
+    /// A regular expression given by the user is invalid.
+    InvalidRegex(regex::Error),
+
+    /// An argument to tac is invalid.
+    InvalidArgument(String),
+
+    /// The specified file is not found on the filesystem.
+    FileNotFound(String),
+
+    /// An error reading the contents of a file or stdin.
+    ///
+    /// The parameters are the name of the file and the underlying
+    /// [`std::io::Error`] that caused this error.
+    ReadError(String, std::io::Error),
+
+    /// An error writing the (reversed) contents of a file or stdin.
+    ///
+    /// The parameter is the underlying [`std::io::Error`] that caused
+    /// this error.
+    WriteError(std::io::Error),
+}
+
+impl UError for TacError {
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+impl Error for TacError {}
+
+impl Display for TacError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TacError::InvalidRegex(e) => write!(f, "invalid regular expression: {}", e),
+            TacError::InvalidArgument(s) => {
+                write!(f, "{}: read error: Invalid argument", s.maybe_quote())
+            }
+            TacError::FileNotFound(s) => write!(
+                f,
+                "failed to open {} for reading: No such file or directory",
+                s.quote()
+            ),
+            TacError::ReadError(s, e) => write!(f, "failed to read from {}: {}", s, e),
+            TacError::WriteError(e) => write!(f, "failed to write to stdout: {}", e),
+        }
+    }
+}
diff --git a/src/uu/tac/src/main.rs b/src/uu/tac/src/main.rs
index 018821c73..7e1437732 100644
--- a/src/uu/tac/src/main.rs
+++ b/src/uu/tac/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_tac);
+uucore::bin!(uu_tac);
diff --git a/src/uu/tac/src/tac.rs b/src/uu/tac/src/tac.rs
index cdb2d74e3..3151b97e2 100644
--- a/src/uu/tac/src/tac.rs
+++ b/src/uu/tac/src/tac.rs
@@ -6,11 +6,9 @@
 //  * file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) sbytes slen dlen memmem memmap Mmap mmap SIGBUS
+mod error;
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use memchr::memmem;
 use memmap2::Mmap;
 use std::io::{stdin, stdout, BufWriter, Read, Write};
@@ -19,10 +17,15 @@ use std::{
     path::Path,
 };
 use uucore::display::Quotable;
+use uucore::error::UError;
+use uucore::error::UResult;
 use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, show};
+
+use crate::error::TacError;
 
 static NAME: &str = "tac";
-static USAGE: &str = "[OPTION]... [FILE]...";
+static USAGE: &str = "{} [OPTION]... [FILE]...";
 static SUMMARY: &str = "Write each file to standard output, last line first.";
 
 mod options {
@@ -32,7 +35,8 @@ mod options {
     pub static FILE: &str = "file";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -53,37 +57,42 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         None => vec!["-"],
     };
 
-    tac(files, before, regex, separator)
+    tac(&files, before, regex, separator)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BEFORE)
-                .short("b")
+            Arg::new(options::BEFORE)
+                .short('b')
                 .long(options::BEFORE)
                 .help("attach the separator before instead of after")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::REGEX)
-                .short("r")
+            Arg::new(options::REGEX)
+                .short('r')
                 .long(options::REGEX)
                 .help("interpret the sequence as a regular expression")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::SEPARATOR)
-                .short("s")
+            Arg::new(options::SEPARATOR)
+                .short('s')
                 .long(options::SEPARATOR)
                 .help("use STRING as the separator instead of newline")
                 .takes_value(true),
         )
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .arg(
+            Arg::new(options::FILE)
+                .hide(true)
+                .multiple_occurrences(true),
+        )
 }
 
 /// Print lines of a buffer in reverse, with line separator given as a regex.
@@ -214,16 +223,18 @@ fn buffer_tac(data: &[u8], before: bool, separator: &str) -> std::io::Result<()>
     Ok(())
 }
 
-fn tac(filenames: Vec<&str>, before: bool, regex: bool, separator: &str) -> i32 {
-    let mut exit_code = 0;
-
-    let pattern = if regex {
-        Some(crash_if_err!(1, regex::bytes::Regex::new(separator)))
+fn tac(filenames: &[&str], before: bool, regex: bool, separator: &str) -> UResult<()> {
+    // Compile the regular expression pattern if it is provided.
+    let maybe_pattern = if regex {
+        match regex::bytes::Regex::new(separator) {
+            Ok(p) => Some(p),
+            Err(e) => return Err(TacError::InvalidRegex(e).into()),
+        }
     } else {
         None
     };
 
-    for &filename in &filenames {
+    for &filename in filenames {
         let mmap;
         let buf;
 
@@ -234,8 +245,8 @@ fn tac(filenames: Vec<&str>, before: bool, regex: bool, separator: &str) -> i32
             } else {
                 let mut buf1 = Vec::new();
                 if let Err(e) = stdin().read_to_end(&mut buf1) {
-                    show_error!("failed to read from stdin: {}", e);
-                    exit_code = 1;
+                    let e: Box<dyn UError> = TacError::ReadError("stdin".to_string(), e).into();
+                    show!(e);
                     continue;
                 }
                 buf = buf1;
@@ -243,16 +254,15 @@ fn tac(filenames: Vec<&str>, before: bool, regex: bool, separator: &str) -> i32
             }
         } else {
             let path = Path::new(filename);
-            if path.is_dir() || path.metadata().is_err() {
-                if path.is_dir() {
-                    show_error!("{}: read error: Invalid argument", filename.maybe_quote());
-                } else {
-                    show_error!(
-                        "failed to open {} for reading: No such file or directory",
-                        filename.quote()
-                    );
-                }
-                exit_code = 1;
+            if path.is_dir() {
+                let e: Box<dyn UError> = TacError::InvalidArgument(String::from(filename)).into();
+                show!(e);
+                continue;
+            }
+
+            if path.metadata().is_err() {
+                let e: Box<dyn UError> = TacError::FileNotFound(String::from(filename)).into();
+                show!(e);
                 continue;
             }
 
@@ -266,22 +276,28 @@ fn tac(filenames: Vec<&str>, before: bool, regex: bool, separator: &str) -> i32
                         &buf
                     }
                     Err(e) => {
-                        show_error!("failed to read {}: {}", filename.quote(), e);
-                        exit_code = 1;
+                        let s = format!("{}", filename.quote());
+                        let e: Box<dyn UError> = TacError::ReadError(s.to_string(), e).into();
+                        show!(e);
                         continue;
                     }
                 }
             }
         };
 
-        if let Some(pattern) = &pattern {
-            buffer_tac_regex(data, pattern, before)
-        } else {
-            buffer_tac(data, before, separator)
+        // Select the appropriate `tac` algorithm based on whether the
+        // separator is given as a regular expression or a fixed string.
+        let result = match maybe_pattern {
+            Some(ref pattern) => buffer_tac_regex(data, pattern, before),
+            None => buffer_tac(data, before, separator),
+        };
+
+        // If there is any error in writing the output, terminate immediately.
+        if let Err(e) = result {
+            return Err(TacError::WriteError(e).into());
         }
-        .unwrap_or_else(|e| crash!(1, "failed to write to stdout: {}", e));
     }
-    exit_code
+    Ok(())
 }
 
 fn try_mmap_stdin() -> Option<Mmap> {
diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml
index 28e7a3bc5..bfa72c143 100644
--- a/src/uu/tail/Cargo.toml
+++ b/src/uu/tail/Cargo.toml
@@ -1,13 +1,13 @@
 # spell-checker:ignore (libs) kqueue
 [package]
 name = "uu_tail"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tail ~ (uutils) display the last lines of input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/tail"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tail"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -16,26 +16,17 @@ edition = "2018"
 path = "src/tail.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
 notify = { version = "5.0.0-pre.14", features=["macos_kqueue"]}
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["ringbuffer"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] }
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version="0.3", features=["fileapi", "handleapi", "processthreadsapi", "synchapi", "winbase"] }
 
-[target.'cfg(target_os = "redox")'.dependencies]
-redox_syscall = "0.2"
-
 [target.'cfg(unix)'.dependencies]
-nix = "0.20"
-libc = "0.2"
+nix = "0.23.1"
 
 [[bin]]
 name = "tail"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/tail/LICENSE b/src/uu/tail/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/tail/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs
index 57a26dabf..270493093 100644
--- a/src/uu/tail/src/chunks.rs
+++ b/src/uu/tail/src/chunks.rs
@@ -13,7 +13,7 @@ pub const BLOCK_SIZE: u64 = 1 << 16;
 ///
 /// Each chunk is a [`Vec`]<[`u8`]> of size [`BLOCK_SIZE`] (except
 /// possibly the last chunk, which might be smaller). Each call to
-/// [`next`] will seek backwards through the given file.
+/// [`ReverseChunks::next`] will seek backwards through the given file.
 pub struct ReverseChunks<'a> {
     /// The file to iterate over, by blocks, from the end to the beginning.
     file: &'a File,
diff --git a/src/uu/tail/src/main.rs b/src/uu/tail/src/main.rs
index dd89ce2c7..6bd55d279 100644
--- a/src/uu/tail/src/main.rs
+++ b/src/uu/tail/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_tail);
+uucore::bin!(uu_tail);
diff --git a/src/uu/tail/src/parse.rs b/src/uu/tail/src/parse.rs
new file mode 100644
index 000000000..ea9df9a02
--- /dev/null
+++ b/src/uu/tail/src/parse.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.
+
+use std::ffi::OsString;
+
+#[derive(PartialEq, Debug)]
+pub enum ParseError {
+    Syntax,
+    Overflow,
+}
+/// Parses obsolete syntax
+/// tail -NUM\[kmzv\] // spell-checker:disable-line
+pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>, ParseError>> {
+    let mut chars = src.char_indices();
+    if let Some((_, '-')) = chars.next() {
+        let mut num_end = 0usize;
+        let mut has_num = false;
+        let mut last_char = 0 as char;
+        for (n, c) in &mut chars {
+            if c.is_digit(10) {
+                has_num = true;
+                num_end = n;
+            } else {
+                last_char = c;
+                break;
+            }
+        }
+        if has_num {
+            match src[1..=num_end].parse::<usize>() {
+                Ok(num) => {
+                    let mut quiet = false;
+                    let mut verbose = false;
+                    let mut zero_terminated = false;
+                    let mut multiplier = None;
+                    let mut c = last_char;
+                    loop {
+                        // not that here, we only match lower case 'k', 'c', and 'm'
+                        match c {
+                            // we want to preserve order
+                            // this also saves us 1 heap allocation
+                            'q' => {
+                                quiet = true;
+                                verbose = false;
+                            }
+                            'v' => {
+                                verbose = true;
+                                quiet = false;
+                            }
+                            'z' => zero_terminated = true,
+                            'c' => multiplier = Some(1),
+                            'b' => multiplier = Some(512),
+                            'k' => multiplier = Some(1024),
+                            'm' => multiplier = Some(1024 * 1024),
+                            '\0' => {}
+                            _ => return Some(Err(ParseError::Syntax)),
+                        }
+                        if let Some((_, next)) = chars.next() {
+                            c = next;
+                        } else {
+                            break;
+                        }
+                    }
+                    let mut options = Vec::new();
+                    if quiet {
+                        options.push(OsString::from("-q"));
+                    }
+                    if verbose {
+                        options.push(OsString::from("-v"));
+                    }
+                    if zero_terminated {
+                        options.push(OsString::from("-z"));
+                    }
+                    if let Some(n) = multiplier {
+                        options.push(OsString::from("-c"));
+                        let num = match num.checked_mul(n) {
+                            Some(n) => n,
+                            None => return Some(Err(ParseError::Overflow)),
+                        };
+                        options.push(OsString::from(format!("{}", num)));
+                    } else {
+                        options.push(OsString::from("-n"));
+                        options.push(OsString::from(format!("{}", num)));
+                    }
+                    Some(Ok(options.into_iter()))
+                }
+                Err(_) => Some(Err(ParseError::Overflow)),
+            }
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn obsolete(src: &str) -> Option<Result<Vec<String>, ParseError>> {
+        let r = parse_obsolete(src);
+        match r {
+            Some(s) => match s {
+                Ok(v) => Some(Ok(v.map(|s| s.to_str().unwrap().to_owned()).collect())),
+                Err(e) => Some(Err(e)),
+            },
+            None => None,
+        }
+    }
+    fn obsolete_result(src: &[&str]) -> Option<Result<Vec<String>, ParseError>> {
+        Some(Ok(src.iter().map(|s| s.to_string()).collect()))
+    }
+    #[test]
+    fn test_parse_numbers_obsolete() {
+        assert_eq!(obsolete("-5"), obsolete_result(&["-n", "5"]));
+        assert_eq!(obsolete("-100"), obsolete_result(&["-n", "100"]));
+        assert_eq!(obsolete("-5m"), obsolete_result(&["-c", "5242880"]));
+        assert_eq!(obsolete("-1k"), obsolete_result(&["-c", "1024"]));
+        assert_eq!(obsolete("-2b"), obsolete_result(&["-c", "1024"]));
+        assert_eq!(obsolete("-1mmk"), obsolete_result(&["-c", "1024"]));
+        assert_eq!(obsolete("-1vz"), obsolete_result(&["-v", "-z", "-n", "1"]));
+        assert_eq!(
+            obsolete("-1vzqvq"), // spell-checker:disable-line
+            obsolete_result(&["-q", "-z", "-n", "1"])
+        );
+        assert_eq!(obsolete("-1vzc"), obsolete_result(&["-v", "-z", "-c", "1"]));
+        assert_eq!(
+            obsolete("-105kzm"),
+            obsolete_result(&["-z", "-c", "110100480"])
+        );
+    }
+    #[test]
+    fn test_parse_errors_obsolete() {
+        assert_eq!(obsolete("-5n"), Some(Err(ParseError::Syntax)));
+        assert_eq!(obsolete("-5c5"), Some(Err(ParseError::Syntax)));
+    }
+    #[test]
+    fn test_parse_obsolete_no_match() {
+        assert_eq!(obsolete("-k"), None);
+        assert_eq!(obsolete("asd"), None);
+    }
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn test_parse_obsolete_overflow_x64() {
+        assert_eq!(
+            obsolete("-1000000000000000m"),
+            Some(Err(ParseError::Overflow))
+        );
+        assert_eq!(
+            obsolete("-10000000000000000000000"),
+            Some(Err(ParseError::Overflow))
+        );
+    }
+    #[test]
+    #[cfg(target_pointer_width = "32")]
+    fn test_parse_obsolete_overflow_x32() {
+        assert_eq!(obsolete("-42949672960"), Some(Err(ParseError::Overflow)));
+        assert_eq!(obsolete("-42949672k"), Some(Err(ParseError::Overflow)));
+    }
+}
diff --git a/src/uu/tail/src/platform/unix.rs b/src/uu/tail/src/platform/unix.rs
index 580a40135..e01d5e444 100644
--- a/src/uu/tail/src/platform/unix.rs
+++ b/src/uu/tail/src/platform/unix.rs
@@ -25,11 +25,12 @@ pub struct ProcessChecker {
 }
 
 impl ProcessChecker {
-    pub fn new(process_id: self::Pid) -> ProcessChecker {
-        ProcessChecker { pid: process_id }
+    pub fn new(process_id: self::Pid) -> Self {
+        Self { pid: process_id }
     }
 
     // Borrowing mutably to be aligned with Windows implementation
+    #[allow(clippy::wrong_self_convention)]
     pub fn is_dead(&mut self) -> bool {
         unsafe { libc::kill(self.pid, 0) != 0 && get_errno() != libc::EPERM }
     }
diff --git a/src/uu/tail/src/platform/windows.rs b/src/uu/tail/src/platform/windows.rs
index 7faa872e6..c63040a2a 100644
--- a/src/uu/tail/src/platform/windows.rs
+++ b/src/uu/tail/src/platform/windows.rs
@@ -24,11 +24,11 @@ pub struct ProcessChecker {
 }
 
 impl ProcessChecker {
-    pub fn new(process_id: self::Pid) -> ProcessChecker {
+    pub fn new(process_id: self::Pid) -> Self {
         #[allow(non_snake_case)]
         let FALSE = 0i32;
         let h = unsafe { OpenProcess(SYNCHRONIZE, FALSE, process_id as DWORD) };
-        ProcessChecker {
+        Self {
             dead: h.is_null(),
             handle: h,
         }
diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs
index 779dc6a08..5734fa79c 100644
--- a/src/uu/tail/src/tail.rs
+++ b/src/uu/tail/src/tail.rs
@@ -23,13 +23,16 @@ extern crate clap;
 extern crate uucore;
 
 mod chunks;
+mod parse;
 mod platform;
 use chunks::ReverseChunks;
 
-use clap::{App, Arg};
+use clap::{Arg, Command};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher, WatcherKind};
 use std::collections::HashMap;
 use std::collections::VecDeque;
+use std::convert::TryInto;
+use std::ffi::OsString;
 use std::fmt;
 use std::fs::{File, Metadata};
 use std::io::{stdin, stdout, BufRead, BufReader, Read, Seek, SeekFrom, Write};
@@ -38,6 +41,9 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::{self, channel};
 use std::time::Duration;
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::format_usage;
+use uucore::lines::lines;
 use uucore::parse_size::{parse_size, ParseSizeError};
 use uucore::ringbuffer::RingBuffer;
 
@@ -53,7 +59,7 @@ const ABOUT: &str = "\
                      \n\
                      Mandatory arguments to long flags are mandatory for short flags too.\
                      ";
-const USAGE: &str = "tail [FLAG]... [FILE]...";
+const USAGE: &str = "{} [FLAG]... [FILE]...";
 
 pub mod text {
     pub static STDIN_STR: &str = "standard input";
@@ -84,12 +90,19 @@ pub mod options {
     pub static FOLLOW_RETRY: &str = "F";
     pub static MAX_UNCHANGED_STATS: &str = "max-unchanged-stats";
     pub static ARG_FILES: &str = "files";
+    pub static PRESUME_INPUT_PIPE: &str = "-presume-input-pipe";
 }
 
 #[derive(Debug)]
 enum FilterMode {
-    Bytes(usize),
-    Lines(usize, u8), // (number of lines, delimiter)
+    Bytes(u64),
+    Lines(u64, u8), // (number of lines, delimiter)
+}
+
+impl Default for FilterMode {
+    fn default() -> Self {
+        Self::Lines(10, b'\n')
+    }
 }
 
 #[derive(Debug, PartialEq)]
@@ -98,7 +111,7 @@ enum FollowMode {
     Name,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 struct Settings {
     mode: FilterMode,
     sleep_sec: Duration,
@@ -109,169 +122,177 @@ struct Settings {
     verbose: bool,
     retry: bool,
     pid: platform::Pid,
+    paths: Vec<PathBuf>,
+    presume_input_pipe: bool,
+    return_code: i32,
 }
 
-impl Default for Settings {
-    fn default() -> Settings {
-        Settings {
-            mode: FilterMode::Lines(10, b'\n'),
+impl Settings {
+    pub fn get_from(args: impl uucore::Args) -> Result<Self, String> {
+        let matches = uu_app().get_matches_from(arg_iterate(args)?);
+
+        let mut settings: Self = Self {
             sleep_sec: Duration::from_secs_f32(1.0),
             max_unchanged_stats: 5,
-            beginning: false,
-            follow: None,
-            use_polling: false,
-            verbose: false,
-            retry: false,
-            pid: 0,
+            ..Default::default()
+        };
+
+        settings.follow = if matches.is_present(options::FOLLOW_RETRY) {
+            Some(FollowMode::Name)
+        } else if matches.occurrences_of(options::FOLLOW) == 0 {
+            None
+        } else if matches.value_of(options::FOLLOW) == Some("name") {
+            Some(FollowMode::Name)
+        } else {
+            Some(FollowMode::Descriptor)
+        };
+
+        if let Some(s) = matches.value_of(options::SLEEP_INT) {
+            settings.sleep_sec = match s.parse::<f32>() {
+                Ok(s) => Duration::from_secs_f32(s),
+                Err(_) => return Err(format!("invalid number of seconds: {}", s.quote())),
+            }
         }
+
+        if let Some(s) = matches.value_of(options::MAX_UNCHANGED_STATS) {
+            settings.max_unchanged_stats = match s.parse::<u32>() {
+                Ok(s) => s,
+                Err(_) => {
+                    // TODO: [2021-10; jhscheer] add test for this
+                    return Err(format!(
+                        "invalid maximum number of unchanged stats between opens: {}",
+                        s.quote()
+                    ));
+                }
+            }
+        }
+
+        if let Some(pid_str) = matches.value_of(options::PID) {
+            if let Ok(pid) = pid_str.parse() {
+                settings.pid = pid;
+                if pid != 0 {
+                    if settings.follow.is_none() {
+                        show_warning!("PID ignored; --pid=PID is useful only when following");
+                    }
+
+                    if !platform::supports_pid_checks(pid) {
+                        show_warning!("--pid=PID is not supported on this system");
+                        settings.pid = 0;
+                    }
+                }
+            }
+        }
+
+        let mode_and_beginning = if let Some(arg) = matches.value_of(options::BYTES) {
+            match parse_num(arg) {
+                Ok((n, beginning)) => (FilterMode::Bytes(n), beginning),
+                Err(e) => return Err(format!("invalid number of bytes: {}", e)),
+            }
+        } else if let Some(arg) = matches.value_of(options::LINES) {
+            match parse_num(arg) {
+                Ok((n, beginning)) => (FilterMode::Lines(n, b'\n'), beginning),
+                Err(e) => return Err(format!("invalid number of lines: {}", e)),
+            }
+        } else {
+            (FilterMode::default(), false)
+        };
+        settings.mode = mode_and_beginning.0;
+        settings.beginning = mode_and_beginning.1;
+
+        settings.use_polling = matches.is_present(options::USE_POLLING);
+        settings.retry =
+            matches.is_present(options::RETRY) || matches.is_present(options::FOLLOW_RETRY);
+
+        if settings.retry && settings.follow.is_none() {
+            show_warning!("--retry ignored; --retry is useful only when following");
+        }
+
+        if matches.is_present(options::ZERO_TERM) {
+            if let FilterMode::Lines(count, _) = settings.mode {
+                settings.mode = FilterMode::Lines(count, 0);
+            }
+        }
+
+        settings.presume_input_pipe = matches.is_present(options::PRESUME_INPUT_PIPE);
+
+        let mut paths = matches
+            .values_of(options::ARG_FILES)
+            .map(|v| v.map(PathBuf::from).collect())
+            .unwrap_or_else(|| vec![PathBuf::from("-")]);
+
+        // Filter out paths depending on `FollowMode`.
+        paths.retain(|path| {
+            if !path.is_stdin() {
+                if !path.is_file() {
+                    settings.return_code = 1;
+                    if settings.follow == Some(FollowMode::Descriptor) && settings.retry {
+                        show_warning!("--retry only effective for the initial open");
+                    }
+                    if path.is_dir() {
+                        show_error!("error reading {}: Is a directory", path.quote());
+                        if settings.follow.is_some() {
+                            let msg = if !settings.retry {
+                                "; giving up on this name"
+                            } else {
+                                ""
+                            };
+                            show_error!(
+                                "{}: cannot follow end of this type of file{}",
+                                path.display(),
+                                msg
+                            );
+                        }
+                    } else {
+                        show_error!(
+                            "cannot open {} for reading: {}",
+                            path.quote(),
+                            text::NO_SUCH_FILE
+                        );
+                    }
+                }
+            } else if settings.follow == Some(FollowMode::Name) {
+                // Mimic GNU's tail; Exit immediately even though there might be other valid files.
+                crash!(1, "cannot follow '-' by name");
+            }
+            if settings.follow == Some(FollowMode::Name) && settings.retry {
+                true
+            } else {
+                !path.is_dir() || path.is_stdin()
+            }
+        });
+        settings.paths = paths.clone();
+
+        settings.verbose = (matches.is_present(options::verbosity::VERBOSE)
+            || settings.paths.len() > 1)
+            && !matches.is_present(options::verbosity::QUIET);
+
+        Ok(settings)
     }
 }
 
-#[allow(clippy::cognitive_complexity)]
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let app = uu_app();
-    let matches = app.get_matches_from(args);
-
-    let mut settings: Settings = Default::default();
-    let mut return_code = 0;
-
-    settings.follow = if matches.is_present(options::FOLLOW_RETRY) {
-        Some(FollowMode::Name)
-    } else if matches.occurrences_of(options::FOLLOW) == 0 {
-        None
-    } else if matches.value_of(options::FOLLOW) == Some("name") {
-        Some(FollowMode::Name)
-    } else {
-        Some(FollowMode::Descriptor)
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let args = match Settings::get_from(args) {
+        Ok(o) => o,
+        Err(s) => {
+            return Err(USimpleError::new(1, s));
+        }
     };
+    uu_tail(&args)
+}
 
-    if let Some(s) = matches.value_of(options::SLEEP_INT) {
-        settings.sleep_sec = match s.parse::<f32>() {
-            Ok(s) => Duration::from_secs_f32(s),
-            Err(_) => crash!(1, "invalid number of seconds: {}", s.quote()),
-        }
-    }
-
-    if let Some(s) = matches.value_of(options::MAX_UNCHANGED_STATS) {
-        settings.max_unchanged_stats = match s.parse::<u32>() {
-            Ok(s) => s,
-            Err(_) => {
-                // TODO: add test for this
-                crash!(
-                    1,
-                    "invalid maximum number of unchanged stats between opens: {}",
-                    s.quote()
-                )
-            }
-        }
-    }
-
-    if let Some(pid_str) = matches.value_of(options::PID) {
-        if let Ok(pid) = pid_str.parse() {
-            settings.pid = pid;
-            if pid != 0 {
-                if settings.follow.is_none() {
-                    show_warning!("PID ignored; --pid=PID is useful only when following");
-                }
-
-                if !platform::supports_pid_checks(pid) {
-                    show_warning!("--pid=PID is not supported on this system");
-                    settings.pid = 0;
-                }
-            }
-        }
-    }
-
-    let mode_and_beginning = if let Some(arg) = matches.value_of(options::BYTES) {
-        match parse_num(arg) {
-            Ok((n, beginning)) => (FilterMode::Bytes(n), beginning),
-            Err(e) => crash!(1, "invalid number of bytes: {}", e.to_string()),
-        }
-    } else if let Some(arg) = matches.value_of(options::LINES) {
-        match parse_num(arg) {
-            Ok((n, beginning)) => (FilterMode::Lines(n, b'\n'), beginning),
-            Err(e) => crash!(1, "invalid number of lines: {}", e.to_string()),
-        }
-    } else {
-        (FilterMode::Lines(10, b'\n'), false)
-    };
-    settings.mode = mode_and_beginning.0;
-    settings.beginning = mode_and_beginning.1;
-
-    settings.use_polling = matches.is_present(options::USE_POLLING);
-    settings.retry =
-        matches.is_present(options::RETRY) || matches.is_present(options::FOLLOW_RETRY);
-
-    if settings.retry && settings.follow.is_none() {
-        show_warning!("--retry ignored; --retry is useful only when following");
-    }
-
-    if matches.is_present(options::ZERO_TERM) {
-        if let FilterMode::Lines(count, _) = settings.mode {
-            settings.mode = FilterMode::Lines(count, 0);
-        }
-    }
-
-    let mut paths: Vec<PathBuf> = matches
-        .values_of(options::ARG_FILES)
-        .map(|v| v.map(PathBuf::from).collect())
-        .unwrap_or_else(|| vec![PathBuf::from("-")]);
-
-    // Filter out paths depending on `FollowMode`.
-    paths.retain(|path| {
-        if !path.is_stdin() {
-            if !path.is_file() {
-                return_code = 1;
-                if settings.follow == Some(FollowMode::Descriptor) && settings.retry {
-                    show_warning!("--retry only effective for the initial open");
-                }
-                if path.is_dir() {
-                    show_error!("error reading {}: Is a directory", path.quote());
-                    if settings.follow.is_some() {
-                        let msg = if !settings.retry {
-                            "; giving up on this name"
-                        } else {
-                            ""
-                        };
-                        show_error!(
-                            "{}: cannot follow end of this type of file{}",
-                            path.display(),
-                            msg
-                        );
-                    }
-                } else {
-                    show_error!(
-                        "cannot open {} for reading: {}",
-                        path.quote(),
-                        text::NO_SUCH_FILE
-                    );
-                }
-            }
-        } else if settings.follow == Some(FollowMode::Name) {
-            // Mimic GNU's tail; Exit immediately even though there might be other valid files.
-            crash!(1, "cannot follow '-' by name");
-        }
-        if settings.follow == Some(FollowMode::Name) && settings.retry {
-            true
-        } else {
-            !path.is_dir() || path.is_stdin()
-        }
-    });
-
-    settings.verbose = (matches.is_present(options::verbosity::VERBOSE) || paths.len() > 1)
-        && !matches.is_present(options::verbosity::QUIET);
-
+fn uu_tail(settings: &Settings) -> UResult<()> {
     let mut first_header = true;
     let mut files = FileHandling {
-        map: HashMap::with_capacity(paths.len()),
+        map: HashMap::with_capacity(settings.paths.len()),
         last: None,
     };
 
     // Do an initial tail print of each path's content.
     // Add `path` to `files` map if `--follow` is selected.
-    for path in &paths {
+    for path in &settings.paths {
         let md = path.metadata().ok();
-        if path.is_stdin() {
+        if path.is_stdin() || settings.presume_input_pipe {
             if settings.verbose {
                 if !first_header {
                     println!();
@@ -279,7 +300,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                 Path::new(text::STDIN_STR).print_header();
             }
             let mut reader = BufReader::new(stdin());
-            unbounded_tail(&mut reader, &settings);
+            unbounded_tail(&mut reader, settings)?;
 
             // Don't follow stdin since there are no checks for pipes/FIFOs
             //
@@ -290,7 +311,6 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             {
                 /*
                 POSIX specification regarding tail -f
-
                 If the input file is a regular file or if the file operand specifies a FIFO, do not
                 terminate after the last line of the input file has been copied, but read and copy
                 further bytes from the input file when they become available. If no file operand is
@@ -323,11 +343,11 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             let mut reader;
 
             if is_seekable(&mut file) && get_block_size(md.as_ref().unwrap()) > 0 {
-                bounded_tail(&mut file, &settings);
+                bounded_tail(&mut file, settings);
                 reader = BufReader::new(file);
             } else {
                 reader = BufReader::new(file);
-                unbounded_tail(&mut reader, &settings);
+                unbounded_tail(&mut reader, settings)?;
             }
             if settings.follow.is_some() {
                 // Insert existing/file `path` into `files.map`.
@@ -364,14 +384,44 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         if files.map.is_empty() || !files.files_remaining() && !settings.retry {
             show_error!("{}", text::NO_FILES_REMAINING);
         } else {
-            follow(&mut files, &settings);
+            follow(&mut files, settings)?;
         }
     }
 
-    return_code
+    if settings.return_code > 0 {
+        return Err(USimpleError::new(settings.return_code, ""));
+    }
+
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
+fn arg_iterate<'a>(
+    mut args: impl uucore::Args + 'a,
+) -> Result<Box<dyn Iterator<Item = OsString> + 'a>, String> {
+    // argv[0] is always present
+    let first = args.next().unwrap();
+    if let Some(second) = args.next() {
+        if let Some(s) = second.to_str() {
+            match parse::parse_obsolete(s) {
+                Some(Ok(iter)) => Ok(Box::new(vec![first].into_iter().chain(iter).chain(args))),
+                Some(Err(e)) => match e {
+                    parse::ParseError::Syntax => Err(format!("bad argument format: {}", s.quote())),
+                    parse::ParseError::Overflow => Err(format!(
+                        "invalid argument: {} Value too large for defined datatype",
+                        s.quote()
+                    )),
+                },
+                None => Ok(Box::new(vec![first, second].into_iter().chain(args))),
+            }
+        } else {
+            Err("bad argument encoding".to_owned())
+        }
+    } else {
+        Ok(Box::new(vec![first].into_iter()))
+    }
+}
+
+pub fn uu_app<'a>() -> Command<'a> {
     #[cfg(target_os = "linux")]
     pub static POLLING_HELP: &str = "Disable 'inotify' support and use polling instead";
     #[cfg(all(unix, not(target_os = "linux")))]
@@ -380,13 +430,14 @@ pub fn uu_app() -> App<'static, 'static> {
     pub static POLLING_HELP: &str =
         "Disable 'ReadDirectoryChanges' support and use polling instead";
 
-    App::new(uucore::util_name())
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BYTES)
-                .short("c")
+            Arg::new(options::BYTES)
+                .short('c')
                 .long(options::BYTES)
                 .takes_value(true)
                 .allow_hyphen_values(true)
@@ -394,8 +445,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .help("Number of bytes to print"),
         )
         .arg(
-            Arg::with_name(options::FOLLOW)
-                .short("f")
+            Arg::new(options::FOLLOW)
+                .short('f')
                 .long(options::FOLLOW)
                 .default_value("descriptor")
                 .takes_value(true)
@@ -406,8 +457,8 @@ pub fn uu_app() -> App<'static, 'static> {
                 .help("Print the file as it grows"),
         )
         .arg(
-            Arg::with_name(options::LINES)
-                .short("n")
+            Arg::new(options::LINES)
+                .short('n')
                 .long(options::LINES)
                 .takes_value(true)
                 .allow_hyphen_values(true)
@@ -415,28 +466,28 @@ pub fn uu_app() -> App<'static, 'static> {
                 .help("Number of lines to print"),
         )
         .arg(
-            Arg::with_name(options::PID)
+            Arg::new(options::PID)
                 .long(options::PID)
                 .takes_value(true)
                 .help("With -f, terminate after process ID, PID dies"),
         )
         .arg(
-            Arg::with_name(options::verbosity::QUIET)
-                .short("q")
+            Arg::new(options::verbosity::QUIET)
+                .short('q')
                 .long(options::verbosity::QUIET)
                 .visible_alias("silent")
                 .overrides_with_all(&[options::verbosity::QUIET, options::verbosity::VERBOSE])
                 .help("Never output headers giving file names"),
         )
         .arg(
-            Arg::with_name(options::SLEEP_INT)
-                .short("s")
+            Arg::new(options::SLEEP_INT)
+                .short('s')
                 .takes_value(true)
                 .long(options::SLEEP_INT)
                 .help("Number or seconds to sleep between polling the file when running with -f"),
         )
         .arg(
-            Arg::with_name(options::MAX_UNCHANGED_STATS)
+            Arg::new(options::MAX_UNCHANGED_STATS)
                 .takes_value(true)
                 .long(options::MAX_UNCHANGED_STATS)
                 .help(
@@ -447,45 +498,51 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::verbosity::VERBOSE)
-                .short("v")
+            Arg::new(options::verbosity::VERBOSE)
+                .short('v')
                 .long(options::verbosity::VERBOSE)
                 .overrides_with_all(&[options::verbosity::QUIET, options::verbosity::VERBOSE])
                 .help("Always output headers giving file names"),
         )
         .arg(
-            Arg::with_name(options::ZERO_TERM)
-                .short("z")
+            Arg::new(options::ZERO_TERM)
+                .short('z')
                 .long(options::ZERO_TERM)
                 .help("Line delimiter is NUL, not newline"),
         )
         .arg(
-            Arg::with_name(options::USE_POLLING)
+            Arg::new(options::USE_POLLING)
                 .visible_alias(options::DISABLE_INOTIFY_TERM)
                 .alias("dis") // Used by GNU's test suite
                 .long(options::USE_POLLING)
                 .help(POLLING_HELP),
         )
         .arg(
-            Arg::with_name(options::RETRY)
+            Arg::new(options::RETRY)
                 .long(options::RETRY)
                 .help("Keep trying to open a file if it is inaccessible"),
         )
         .arg(
-            Arg::with_name(options::FOLLOW_RETRY)
-                .short(options::FOLLOW_RETRY)
+            Arg::new(options::FOLLOW_RETRY)
+                .short('F')
                 .help("Same as --follow=name --retry")
                 .overrides_with_all(&[options::RETRY, options::FOLLOW]),
         )
         .arg(
-            Arg::with_name(options::ARG_FILES)
-                .multiple(true)
+            Arg::new(options::PRESUME_INPUT_PIPE)
+                .long(options::PRESUME_INPUT_PIPE)
+                .alias(options::PRESUME_INPUT_PIPE)
+                .hide(true),
+        )
+        .arg(
+            Arg::new(options::ARG_FILES)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .min_values(1),
         )
 }
 
-fn follow(files: &mut FileHandling, settings: &Settings) {
+fn follow(files: &mut FileHandling, settings: &Settings) -> UResult<()> {
     let mut process = platform::ProcessChecker::new(settings.pid);
 
     let (tx, rx) = channel();
@@ -526,7 +583,7 @@ fn follow(files: &mut FileHandling, settings: &Settings) {
         } else if settings.follow.is_some() && settings.retry {
             if path.is_orphan() {
                 orphans.push(path.to_path_buf());
-                // TODO: add test for this
+                // TODO: [2021-10; jhscheer] add test for this
             } else {
                 let parent = path.parent().unwrap();
                 watcher
@@ -534,7 +591,7 @@ fn follow(files: &mut FileHandling, settings: &Settings) {
                     .unwrap();
             }
         } else {
-            unreachable!()
+            unreachable!();
         }
     }
 
@@ -549,25 +606,25 @@ fn follow(files: &mut FileHandling, settings: &Settings) {
         // To be able to differentiate between the cases of test_retry8 and test_retry9,
         // here paths will not be removed from orphans if the path becomes available.
         if settings.retry && settings.follow == Some(FollowMode::Name) {
-            for new_path in orphans.iter() {
+            for new_path in &orphans {
                 if new_path.exists() {
                     let display_name = files.map.get(new_path).unwrap().display_name.to_path_buf();
                     if new_path.is_file() && files.map.get(new_path).unwrap().metadata.is_none() {
-                        // TODO: add test for this
+                        // TODO: [2021-10; jhscheer] add test for this
                         show_error!("{} has appeared;  following new file", display_name.quote());
                         if let Ok(new_path_canonical) = new_path.canonicalize() {
                             files.update_metadata(&new_path_canonical, None);
                             files.reopen_file(&new_path_canonical).unwrap();
-                            read_some = files.print_file(&new_path_canonical, settings);
+                            read_some = files.print_file(&new_path_canonical, settings)?;
                             let new_path = get_path(&new_path_canonical, settings);
                             watcher
                                 .watch(&new_path, RecursiveMode::NonRecursive)
                                 .unwrap();
                         } else {
-                            unreachable!()
+                            unreachable!();
                         }
                     } else if new_path.is_dir() {
-                        // TODO: does is_dir() need handling?
+                        // TODO: [2021-10; jhscheer] does is_dir() need handling?
                         todo!();
                     }
                 }
@@ -581,30 +638,25 @@ fn follow(files: &mut FileHandling, settings: &Settings) {
         }
         match rx_result {
             Ok(Ok(event)) => {
-                // eprintln!("=={:=>3}===========================", _event_counter);
-                // dbg!(&event);
-                // dbg!(files.map.keys());
-                // eprintln!("=={:=>3}===========================", _event_counter);
-                handle_event(event, files, settings, &mut watcher, &mut orphans);
+                handle_event(&event, files, settings, &mut watcher, &mut orphans);
             }
             Ok(Err(notify::Error {
                 kind: notify::ErrorKind::Io(ref e),
                 paths,
             })) if e.kind() == std::io::ErrorKind::NotFound => {
-                // dbg!(e, &paths);
-                // TODO: is this still needed ?
+                // TODO: [2021-10; jhscheer] is this case still needed ?
                 if let Some(event_path) = paths.first() {
                     if files.map.contains_key(event_path) {
-                        // TODO: handle this case for --follow=name --retry
+                        // TODO: [2021-10; jhscheer] handle this case for --follow=name --retry
                         let _ = watcher.unwatch(event_path);
-                        // TODO: add test for this
+                        // TODO: [2021-10; jhscheer] add test for this
                         show_error!(
                             "{}: {}",
                             files.map.get(event_path).unwrap().display_name.display(),
                             text::NO_SUCH_FILE
                         );
                         if !files.files_remaining() && !settings.retry {
-                            // TODO: add test for this
+                            // TODO: [2021-10; jhscheer] add test for this
                             crash!(1, "{}", text::NO_FILES_REMAINING);
                         }
                     }
@@ -622,7 +674,7 @@ fn follow(files: &mut FileHandling, settings: &Settings) {
         }
 
         for path in files.map.keys().cloned().collect::<Vec<_>>() {
-            read_some = files.print_file(&path, settings);
+            read_some = files.print_file(&path, settings)?;
         }
 
         if !read_some && settings.pid != 0 && process.is_dead() {
@@ -644,10 +696,11 @@ fn follow(files: &mut FileHandling, settings: &Settings) {
             // tail checks whether process p is alive at least every N seconds
         }
     }
+    Ok(())
 }
 
 fn handle_event(
-    event: notify::Event,
+    event: &notify::Event,
     files: &mut FileHandling,
     settings: &Settings,
     watcher: &mut Box<dyn Watcher>,
@@ -664,7 +717,6 @@ fn handle_event(
                 .display_name
                 .to_path_buf();
             match event.kind {
-                // notify::EventKind::Any => {}
                 EventKind::Access(AccessKind::Close(AccessMode::Write))
                 | EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))
                 | EventKind::Modify(ModifyKind::Metadata(MetadataKind::WriteTime))
@@ -695,7 +747,7 @@ fn handle_event(
                             } else if new_md.len() <= old_md.len()
                                 && new_md.modified().unwrap() != old_md.modified().unwrap()
                             {
-                                // TODO: add test for this
+                                // TODO: [2021-10; jhscheer] add test for this
                                 show_error!("{}: file truncated", display_name.display());
                                 files.update_metadata(event_path, None);
                                 files.reopen_file(event_path).unwrap();
@@ -709,7 +761,7 @@ fn handle_event(
                 | EventKind::Modify(ModifyKind::Name(RenameMode::To)) => {
                     if event_path.is_file() {
                         if settings.follow.is_some() {
-                            // TODO: add test for this
+                            // TODO: [2021-10; jhscheer] add test for this
                             let msg = if settings.use_polling && !settings.retry {
                                 format!("{} has been replaced", display_name.quote())
                             } else {
@@ -724,7 +776,7 @@ fn handle_event(
                         // behavior and is the usual truncation operation for log files.
                         files.reopen_file(event_path).unwrap();
                         if settings.follow == Some(FollowMode::Name) && settings.retry {
-                            // TODO: add test for this
+                            // TODO: [2021-10; jhscheer] add test for this
                             // Path has appeared, it's not an orphan any more.
                             orphans.retain(|path| path != event_path);
                         }
@@ -745,15 +797,13 @@ fn handle_event(
                                     crash!(1, "{}", text::NO_FILES_REMAINING);
                                 }
                             } else if settings.follow == Some(FollowMode::Name) {
-                                // TODO: add test for this
+                                // TODO: [2021-10; jhscheer] add test for this
                                 files.update_metadata(event_path, None);
                                 show_error!("{} {}", display_name.quote(), msg);
                             }
                         }
                     }
                 }
-                // EventKind::Modify(ModifyKind::Metadata(_)) => {}
-                // | EventKind::Remove(RemoveKind::Folder)
                 EventKind::Remove(RemoveKind::File) | EventKind::Remove(RemoveKind::Any) => {
                     if settings.follow == Some(FollowMode::Name) {
                         if settings.retry {
@@ -848,8 +898,7 @@ fn handle_event(
                             .unwrap();
                     }
                 }
-                // notify::EventKind::Other => {}
-                _ => {} // println!("{:?}", event.kind),
+                _ => {}
             }
         }
     }
@@ -866,7 +915,7 @@ fn get_path(path: &Path, settings: &Settings) -> PathBuf {
         let parent = path
             .parent()
             .unwrap_or_else(|| crash!(1, "cannot watch parent directory of {}", path.display()));
-        // TODO: add test for this - "cannot watch parent directory"
+        // TODO: [2021-10; jhscheer] add test for this - "cannot watch parent directory"
         if parent.is_dir() {
             parent.to_path_buf()
         } else {
@@ -905,7 +954,7 @@ impl FileHandling {
         false
     }
 
-    // TODO: change to update_reader() without error return
+    // TODO: [2021-10; jhscheer] change to update_reader() without error return
     fn reopen_file(&mut self, path: &Path) -> Result<(), Error> {
         assert!(self.map.contains_key(path));
         if let Some(pd) = self.map.get_mut(path) {
@@ -931,7 +980,7 @@ impl FileHandling {
     }
 
     // This prints from the current seek position forward.
-    fn print_file(&mut self, path: &Path, settings: &Settings) -> bool {
+    fn print_file(&mut self, path: &Path, settings: &Settings) -> UResult<bool> {
         assert!(self.map.contains_key(path));
         let mut last_display_name = self
             .map
@@ -940,11 +989,12 @@ impl FileHandling {
             .display_name
             .to_path_buf();
         let mut read_some = false;
+        let mut stdout = stdout();
         let pd = self.map.get_mut(path).unwrap();
         if let Some(reader) = pd.reader.as_mut() {
             loop {
-                let mut datum = String::new();
-                match reader.read_line(&mut datum) {
+                let mut datum = vec![];
+                match reader.read_until(b'\n', &mut datum) {
                     Ok(0) => break,
                     Ok(_) => {
                         read_some = true;
@@ -956,26 +1006,105 @@ impl FileHandling {
                                 pd.display_name.print_header();
                             }
                         }
-                        print!("{}", datum);
+                        stdout
+                            .write_all(&datum)
+                            .map_err_context(|| String::from("write error"))?;
                     }
-                    Err(err) => panic!("{}", err),
+                    Err(err) => return Err(USimpleError::new(1, err.to_string())),
                 }
             }
         } else {
-            return read_some;
+            return Ok(read_some);
         }
         if read_some {
             self.update_metadata(path, None);
-            // TODO: add test for this
+            // TODO: [2021-10; jhscheer] add test for this
         }
-        read_some
+        Ok(read_some)
     }
 }
 
+/// Find the index after the given number of instances of a given byte.
+///
+/// This function reads through a given reader until `num_delimiters`
+/// instances of `delimiter` have been seen, returning the index of
+/// the byte immediately following that delimiter. If there are fewer
+/// than `num_delimiters` instances of `delimiter`, this returns the
+/// total number of bytes read from the `reader` until EOF.
+///
+/// # Errors
+///
+/// This function returns an error if there is an error during reading
+/// from `reader`.
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```rust,ignore
+/// use std::io::Cursor;
+///
+/// let mut reader = Cursor::new("a\nb\nc\nd\ne\n");
+/// let i = forwards_thru_file(&mut reader, 2, b'\n').unwrap();
+/// assert_eq!(i, 4);
+/// ```
+///
+/// If `num_delimiters` is zero, then this function always returns
+/// zero:
+///
+/// ```rust,ignore
+/// use std::io::Cursor;
+///
+/// let mut reader = Cursor::new("a\n");
+/// let i = forwards_thru_file(&mut reader, 0, b'\n').unwrap();
+/// assert_eq!(i, 0);
+/// ```
+///
+/// If there are fewer than `num_delimiters` instances of `delimiter`
+/// in the reader, then this function returns the total number of
+/// bytes read:
+///
+/// ```rust,ignore
+/// use std::io::Cursor;
+///
+/// let mut reader = Cursor::new("a\n");
+/// let i = forwards_thru_file(&mut reader, 2, b'\n').unwrap();
+/// assert_eq!(i, 2);
+/// ```
+fn forwards_thru_file<R>(
+    reader: &mut R,
+    num_delimiters: u64,
+    delimiter: u8,
+) -> std::io::Result<usize>
+where
+    R: Read,
+{
+    let mut reader = BufReader::new(reader);
+
+    let mut buf = vec![];
+    let mut total = 0;
+    for _ in 0..num_delimiters {
+        match reader.read_until(delimiter, &mut buf) {
+            Ok(0) => {
+                return Ok(total);
+            }
+            Ok(n) => {
+                total += n;
+                buf.clear();
+                continue;
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        }
+    }
+    Ok(total)
+}
+
 /// Iterate over bytes in the file, in reverse, until we find the
 /// `num_delimiters` instance of `delimiter`. The `file` is left seek'd to the
 /// position just after that delimiter.
-fn backwards_thru_file(file: &mut File, num_delimiters: usize, delimiter: u8) {
+fn backwards_thru_file(file: &mut File, num_delimiters: u64, delimiter: u8) {
     // This variable counts the number of delimiters found in the file
     // so far (reading from the end of the file toward the beginning).
     let mut counter = 0;
@@ -1020,12 +1149,22 @@ fn backwards_thru_file(file: &mut File, num_delimiters: usize, delimiter: u8) {
 /// being a nice performance win for very large files.
 fn bounded_tail(file: &mut File, settings: &Settings) {
     // Find the position in the file to start printing from.
-    match settings.mode {
-        FilterMode::Lines(count, delimiter) => {
-            backwards_thru_file(file, count as usize, delimiter);
+    match (&settings.mode, settings.beginning) {
+        (FilterMode::Lines(count, delimiter), false) => {
+            backwards_thru_file(file, *count, *delimiter);
         }
-        FilterMode::Bytes(count) => {
-            file.seek(SeekFrom::End(-(count as i64))).unwrap();
+        (FilterMode::Lines(count, delimiter), true) => {
+            let i = forwards_thru_file(file, (*count).max(1) - 1, *delimiter).unwrap();
+            file.seek(SeekFrom::Start(i as u64)).unwrap();
+        }
+        (FilterMode::Bytes(count), false) => {
+            file.seek(SeekFrom::End(-(*count as i64))).unwrap();
+        }
+        (FilterMode::Bytes(count), true) => {
+            // GNU `tail` seems to index bytes and lines starting at 1, not
+            // at 0. It seems to treat `+0` and `+1` as the same thing.
+            file.seek(SeekFrom::Start(((*count).max(1) - 1) as u64))
+                .unwrap();
         }
     }
 
@@ -1035,6 +1174,18 @@ fn bounded_tail(file: &mut File, settings: &Settings) {
     std::io::copy(file, &mut stdout).unwrap();
 }
 
+/// An alternative to [`Iterator::skip`] with u64 instead of usize. This is
+/// necessary because the usize limit doesn't make sense when iterating over
+/// something that's not in memory. For example, a very large file. This allows
+/// us to skip data larger than 4 GiB even on 32-bit platforms.
+fn skip_u64(iter: &mut impl Iterator, num: u64) {
+    for _ in 0..num {
+        if iter.next().is_none() {
+            break;
+        }
+    }
+}
+
 /// Collect the last elements of an iterator into a `VecDeque`.
 ///
 /// This function returns a [`VecDeque`] containing either the last
@@ -1047,10 +1198,10 @@ fn bounded_tail(file: &mut File, settings: &Settings) {
 ///
 /// If any element of `iter` is an [`Err`], then this function panics.
 fn unbounded_tail_collect<T, E>(
-    iter: impl Iterator<Item = Result<T, E>>,
-    count: usize,
+    mut iter: impl Iterator<Item = Result<T, E>>,
+    count: u64,
     beginning: bool,
-) -> VecDeque<T>
+) -> UResult<VecDeque<T>>
 where
     E: fmt::Debug,
 {
@@ -1058,29 +1209,38 @@ where
         // GNU `tail` seems to index bytes and lines starting at 1, not
         // at 0. It seems to treat `+0` and `+1` as the same thing.
         let i = count.max(1) - 1;
-        iter.skip(i as usize).map(|r| r.unwrap()).collect()
+        skip_u64(&mut iter, i);
+        Ok(iter.map(|r| r.unwrap()).collect())
     } else {
-        RingBuffer::from_iter(iter.map(|r| r.unwrap()), count as usize).data
+        let count: usize = count
+            .try_into()
+            .map_err(|_| USimpleError::new(1, "Insufficient addressable memory"))?;
+        Ok(RingBuffer::from_iter(iter.map(|r| r.unwrap()), count).data)
     }
 }
 
-fn unbounded_tail<T: Read>(reader: &mut BufReader<T>, settings: &Settings) {
+fn unbounded_tail<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
     // Read through each line/char and store them in a ringbuffer that always
     // contains count lines/chars. When reaching the end of file, output the
     // data in the ringbuf.
     match settings.mode {
-        FilterMode::Lines(count, _) => {
-            for line in unbounded_tail_collect(reader.lines(), count, settings.beginning) {
-                println!("{}", line);
+        FilterMode::Lines(count, sep) => {
+            let mut stdout = stdout();
+            for line in unbounded_tail_collect(lines(reader, sep), count, settings.beginning)? {
+                stdout
+                    .write_all(&line)
+                    .map_err_context(|| String::from("IO error"))?;
             }
         }
         FilterMode::Bytes(count) => {
-            for byte in unbounded_tail_collect(reader.bytes(), count, settings.beginning) {
-                let mut stdout = stdout();
-                print_byte(&mut stdout, byte);
+            for byte in unbounded_tail_collect(reader.bytes(), count, settings.beginning)? {
+                if let Err(err) = stdout().write(&[byte]) {
+                    return Err(USimpleError::new(1, err.to_string()));
+                }
             }
         }
     }
+    Ok(())
 }
 
 fn is_seekable<T: Seek>(file: &mut T) -> bool {
@@ -1089,14 +1249,7 @@ fn is_seekable<T: Seek>(file: &mut T) -> bool {
         && file.seek(SeekFrom::Start(0)).is_ok()
 }
 
-#[inline]
-fn print_byte<T: Write>(stdout: &mut T, ch: u8) {
-    if let Err(err) = stdout.write(&[ch]) {
-        crash!(1, "{}", err);
-    }
-}
-
-fn parse_num(src: &str) -> Result<(usize, bool), ParseSizeError> {
+fn parse_num(src: &str) -> Result<(u64, bool), ParseSizeError> {
     let mut size_string = src.trim();
     let mut starting_with = false;
 
@@ -1143,3 +1296,32 @@ impl PathExt for Path {
         !matches!(self.parent(), Some(parent) if parent.is_dir())
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::forwards_thru_file;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_forwards_thru_file_zero() {
+        let mut reader = Cursor::new("a\n");
+        let i = forwards_thru_file(&mut reader, 0, b'\n').unwrap();
+        assert_eq!(i, 0);
+    }
+
+    #[test]
+    fn test_forwards_thru_file_basic() {
+        //                   01 23 45 67 89
+        let mut reader = Cursor::new("a\nb\nc\nd\ne\n");
+        let i = forwards_thru_file(&mut reader, 2, b'\n').unwrap();
+        assert_eq!(i, 4);
+    }
+
+    #[test]
+    fn test_forwards_thru_file_past_end() {
+        let mut reader = Cursor::new("x\n");
+        let i = forwards_thru_file(&mut reader, 2, b'\n').unwrap();
+        assert_eq!(i, 2);
+    }
+}
diff --git a/src/uu/tee/Cargo.toml b/src/uu/tee/Cargo.toml
index 00a250565..1fd255fcf 100644
--- a/src/uu/tee/Cargo.toml
+++ b/src/uu/tee/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_tee"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tee ~ (uutils) display input and copy to FILE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/tee"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tee"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,16 +15,11 @@ edition = "2018"
 path = "src/tee.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-retain_mut = "0.1.2"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["libc"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+retain_mut = "=0.1.2" # ToDO: [2021-01-01; rivy; maint/MinSRV] ~ v0.1.5 uses const generics which aren't stabilized until rust v1.51.0
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["libc"] }
 
 [[bin]]
 name = "tee"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/tee/LICENSE b/src/uu/tee/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/tee/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/tee/src/main.rs b/src/uu/tee/src/main.rs
index 2b483d9d8..59bb3184b 100644
--- a/src/uu/tee/src/main.rs
+++ b/src/uu/tee/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_tee);
+uucore::bin!(uu_tee);
diff --git a/src/uu/tee/src/tee.rs b/src/uu/tee/src/tee.rs
index d2fb015bf..d9c2e78f1 100644
--- a/src/uu/tee/src/tee.rs
+++ b/src/uu/tee/src/tee.rs
@@ -8,17 +8,20 @@
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use retain_mut::RetainMut;
 use std::fs::OpenOptions;
 use std::io::{copy, sink, stdin, stdout, Error, ErrorKind, Read, Result, Write};
 use std::path::PathBuf;
 use uucore::display::Quotable;
+use uucore::error::UResult;
+use uucore::format_usage;
 
 #[cfg(unix)]
 use uucore::libc;
 
 static ABOUT: &str = "Copy standard input to each FILE, and also to standard output.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
 mod options {
     pub const APPEND: &str = "append";
@@ -33,14 +36,9 @@ struct Options {
     files: Vec<String>,
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
-
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
     let options = Options {
         append: matches.is_present(options::APPEND),
@@ -51,30 +49,32 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
             .unwrap_or_default(),
     };
 
-    match tee(options) {
-        Ok(_) => 0,
-        Err(_) => 1,
+    match tee(&options) {
+        Ok(_) => Ok(()),
+        Err(_) => Err(1.into()),
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .after_help("If a FILE is -, it refers to a file named - .")
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::APPEND)
+            Arg::new(options::APPEND)
                 .long(options::APPEND)
-                .short("a")
+                .short('a')
                 .help("append to the given FILEs, do not overwrite"),
         )
         .arg(
-            Arg::with_name(options::IGNORE_INTERRUPTS)
+            Arg::new(options::IGNORE_INTERRUPTS)
                 .long(options::IGNORE_INTERRUPTS)
-                .short("i")
+                .short('i')
                 .help("ignore interrupt signals (ignored on non-Unix platforms)"),
         )
-        .arg(Arg::with_name(options::FILE).multiple(true))
+        .arg(Arg::new(options::FILE).multiple_occurrences(true))
 }
 
 #[cfg(unix)]
@@ -92,9 +92,9 @@ fn ignore_interrupts() -> Result<()> {
     Ok(())
 }
 
-fn tee(options: Options) -> Result<()> {
+fn tee(options: &Options) -> Result<()> {
     if options.ignore_interrupts {
-        ignore_interrupts()?
+        ignore_interrupts()?;
     }
     let mut writers: Vec<NamedWriter> = options
         .files
@@ -164,7 +164,7 @@ impl MultiWriter {
 
 impl Write for MultiWriter {
     fn write(&mut self, buf: &[u8]) -> Result<usize> {
-        self.writers.retain_mut(|writer| {
+        RetainMut::retain_mut(&mut self.writers, |writer| {
             let result = writer.write_all(buf);
             match result {
                 Err(f) => {
@@ -178,7 +178,7 @@ impl Write for MultiWriter {
     }
 
     fn flush(&mut self) -> Result<()> {
-        self.writers.retain_mut(|writer| {
+        RetainMut::retain_mut(&mut self.writers, |writer| {
             let result = writer.flush();
             match result {
                 Err(f) => {
diff --git a/src/uu/test/Cargo.toml b/src/uu/test/Cargo.toml
index 633e0f323..002eda823 100644
--- a/src/uu/test/Cargo.toml
+++ b/src/uu/test/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_test"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "test ~ (uutils) evaluate comparison and file type expressions"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/test"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/test"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/test.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [target.'cfg(target_os = "redox")'.dependencies]
 redox_syscall = "0.2"
@@ -26,7 +25,3 @@ redox_syscall = "0.2"
 [[bin]]
 name = "test"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/test/LICENSE b/src/uu/test/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/test/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/test/src/main.rs b/src/uu/test/src/main.rs
index 9f4e6985f..58f20bea4 100644
--- a/src/uu/test/src/main.rs
+++ b/src/uu/test/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_test);
+uucore::bin!(uu_test);
diff --git a/src/uu/test/src/parser.rs b/src/uu/test/src/parser.rs
index ce4c0dec0..d8d7ce802 100644
--- a/src/uu/test/src/parser.rs
+++ b/src/uu/test/src/parser.rs
@@ -44,26 +44,26 @@ impl Symbol {
     /// Create a new Symbol from an OsString.
     ///
     /// Returns Symbol::None in place of None
-    fn new(token: Option<OsString>) -> Symbol {
+    fn new(token: Option<OsString>) -> Self {
         match token {
             Some(s) => match s.to_str() {
                 Some(t) => match t {
-                    "(" => Symbol::LParen,
-                    "!" => Symbol::Bang,
-                    "-a" | "-o" => Symbol::BoolOp(s),
-                    "=" | "==" | "!=" => Symbol::Op(Operator::String(s)),
-                    "-eq" | "-ge" | "-gt" | "-le" | "-lt" | "-ne" => Symbol::Op(Operator::Int(s)),
-                    "-ef" | "-nt" | "-ot" => Symbol::Op(Operator::File(s)),
-                    "-n" | "-z" => Symbol::UnaryOp(UnaryOperator::StrlenOp(s)),
+                    "(" => Self::LParen,
+                    "!" => Self::Bang,
+                    "-a" | "-o" => Self::BoolOp(s),
+                    "=" | "==" | "!=" => Self::Op(Operator::String(s)),
+                    "-eq" | "-ge" | "-gt" | "-le" | "-lt" | "-ne" => Self::Op(Operator::Int(s)),
+                    "-ef" | "-nt" | "-ot" => Self::Op(Operator::File(s)),
+                    "-n" | "-z" => Self::UnaryOp(UnaryOperator::StrlenOp(s)),
                     "-b" | "-c" | "-d" | "-e" | "-f" | "-g" | "-G" | "-h" | "-k" | "-L" | "-O"
                     | "-p" | "-r" | "-s" | "-S" | "-t" | "-u" | "-w" | "-x" => {
-                        Symbol::UnaryOp(UnaryOperator::FiletestOp(s))
+                        Self::UnaryOp(UnaryOperator::FiletestOp(s))
                     }
-                    _ => Symbol::Literal(s),
+                    _ => Self::Literal(s),
                 },
-                None => Symbol::Literal(s),
+                None => Self::Literal(s),
             },
-            None => Symbol::None,
+            None => Self::None,
         }
     }
 
@@ -74,18 +74,18 @@ impl Symbol {
     /// # Panics
     ///
     /// Panics if `self` is Symbol::None
-    fn into_literal(self) -> Symbol {
-        Symbol::Literal(match self {
-            Symbol::LParen => OsString::from("("),
-            Symbol::Bang => OsString::from("!"),
-            Symbol::BoolOp(s)
-            | Symbol::Literal(s)
-            | Symbol::Op(Operator::String(s))
-            | Symbol::Op(Operator::Int(s))
-            | Symbol::Op(Operator::File(s))
-            | Symbol::UnaryOp(UnaryOperator::StrlenOp(s))
-            | Symbol::UnaryOp(UnaryOperator::FiletestOp(s)) => s,
-            Symbol::None => panic!(),
+    fn into_literal(self) -> Self {
+        Self::Literal(match self {
+            Self::LParen => OsString::from("("),
+            Self::Bang => OsString::from("!"),
+            Self::BoolOp(s)
+            | Self::Literal(s)
+            | Self::Op(Operator::String(s))
+            | Self::Op(Operator::Int(s))
+            | Self::Op(Operator::File(s))
+            | Self::UnaryOp(UnaryOperator::StrlenOp(s))
+            | Self::UnaryOp(UnaryOperator::FiletestOp(s)) => s,
+            Self::None => panic!(),
         })
     }
 }
@@ -120,8 +120,8 @@ struct Parser {
 
 impl Parser {
     /// Construct a new Parser from a `Vec<OsString>` of tokens.
-    fn new(tokens: Vec<OsString>) -> Parser {
-        Parser {
+    fn new(tokens: Vec<OsString>) -> Self {
+        Self {
             tokens: tokens.into_iter().peekable(),
             stack: vec![],
         }
diff --git a/src/uu/test/src/test.rs b/src/uu/test/src/test.rs
index 5ce798bfa..e53ba4db1 100644
--- a/src/uu/test/src/test.rs
+++ b/src/uu/test/src/test.rs
@@ -10,16 +10,19 @@
 
 mod parser;
 
-use clap::{crate_version, App, AppSettings};
+use clap::{crate_version, Command};
 use parser::{parse, Operator, Symbol, UnaryOperator};
 use std::ffi::{OsStr, OsString};
-use uucore::{display::Quotable, show_error};
+use uucore::display::Quotable;
+use uucore::error::{UResult, USimpleError};
+use uucore::format_usage;
 
-const USAGE: &str = "test EXPRESSION
-or:  test
-or:  [ EXPRESSION ]
-or:  [ ]
-or:  [ OPTION";
+const USAGE: &str = "\
+    {} EXPRESSION
+    {}
+    [ EXPRESSION ]
+    [ ]
+    [ 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 = "
@@ -85,13 +88,18 @@ NOTE: your shell may have its own version of test and/or [, which usually supers
 the version described here.  Please refer to your shell's documentation
 for details about the options it supports.";
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
-        .setting(AppSettings::DisableHelpFlags)
-        .setting(AppSettings::DisableVersion)
+const ABOUT: &str = "Check file types and compare values.";
+
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .version(crate_version!())
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .after_help(AFTER_HELP)
 }
 
-pub fn uumain(mut args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     let program = args.next().unwrap_or_else(|| OsString::from("test"));
     let binary_name = uucore::util_name();
     let mut args: Vec<_> = args.collect();
@@ -100,22 +108,20 @@ pub fn uumain(mut args: impl uucore::Args) -> i32 {
         // If invoked as [ we should recognize --help and --version (but not -h or -v)
         if args.len() == 1 && (args[0] == "--help" || args[0] == "--version") {
             // Let clap pretty-print help and version
-            App::new(binary_name)
+            Command::new(binary_name)
                 .version(crate_version!())
-                .usage(USAGE)
+                .about(ABOUT)
+                .override_usage(format_usage(USAGE))
                 .after_help(AFTER_HELP)
                 // Disable printing of -h and -v as valid alternatives for --help and --version,
                 // since we don't recognize -h and -v as help/version flags.
-                .setting(AppSettings::NeedsLongHelp)
-                .setting(AppSettings::NeedsLongVersion)
                 .get_matches_from(std::iter::once(program).chain(args.into_iter()));
-            return 0;
+            return Ok(());
         }
         // If invoked via name '[', matching ']' must be in the last arg
         let last = args.pop();
         if last.as_deref() != Some(OsStr::new("]")) {
-            show_error!("missing ']'");
-            return 2;
+            return Err(USimpleError::new(2, "missing ']'"));
         }
     }
 
@@ -124,15 +130,12 @@ pub fn uumain(mut args: impl uucore::Args) -> i32 {
     match result {
         Ok(result) => {
             if result {
-                0
+                Ok(())
             } else {
-                1
+                Err(1.into())
             }
         }
-        Err(e) => {
-            show_error!("{}", e);
-            2
-        }
+        Err(e) => Err(USimpleError::new(2, e)),
     }
 }
 
@@ -192,37 +195,36 @@ fn eval(stack: &mut Vec<Symbol>) -> Result<bool, String> {
             let f = pop_literal!();
 
             Ok(match op {
-                "-b" => path(&f, PathCondition::BlockSpecial),
-                "-c" => path(&f, PathCondition::CharacterSpecial),
-                "-d" => path(&f, PathCondition::Directory),
-                "-e" => path(&f, PathCondition::Exists),
-                "-f" => path(&f, PathCondition::Regular),
-                "-g" => path(&f, PathCondition::GroupIdFlag),
-                "-G" => path(&f, PathCondition::GroupOwns),
-                "-h" => path(&f, PathCondition::SymLink),
-                "-k" => path(&f, PathCondition::Sticky),
-                "-L" => path(&f, PathCondition::SymLink),
-                "-O" => path(&f, PathCondition::UserOwns),
-                "-p" => path(&f, PathCondition::Fifo),
-                "-r" => path(&f, PathCondition::Readable),
-                "-S" => path(&f, PathCondition::Socket),
-                "-s" => path(&f, PathCondition::NonEmpty),
+                "-b" => path(&f, &PathCondition::BlockSpecial),
+                "-c" => path(&f, &PathCondition::CharacterSpecial),
+                "-d" => path(&f, &PathCondition::Directory),
+                "-e" => path(&f, &PathCondition::Exists),
+                "-f" => path(&f, &PathCondition::Regular),
+                "-g" => path(&f, &PathCondition::GroupIdFlag),
+                "-G" => path(&f, &PathCondition::GroupOwns),
+                "-h" => path(&f, &PathCondition::SymLink),
+                "-k" => path(&f, &PathCondition::Sticky),
+                "-L" => path(&f, &PathCondition::SymLink),
+                "-O" => path(&f, &PathCondition::UserOwns),
+                "-p" => path(&f, &PathCondition::Fifo),
+                "-r" => path(&f, &PathCondition::Readable),
+                "-S" => path(&f, &PathCondition::Socket),
+                "-s" => path(&f, &PathCondition::NonEmpty),
                 "-t" => isatty(&f)?,
-                "-u" => path(&f, PathCondition::UserIdFlag),
-                "-w" => path(&f, PathCondition::Writable),
-                "-x" => path(&f, PathCondition::Executable),
+                "-u" => path(&f, &PathCondition::UserIdFlag),
+                "-w" => path(&f, &PathCondition::Writable),
+                "-x" => path(&f, &PathCondition::Executable),
                 _ => panic!(),
             })
         }
         Some(Symbol::Literal(s)) => Ok(!s.is_empty()),
-        Some(Symbol::None) => Ok(false),
+        Some(Symbol::None) | None => Ok(false),
         Some(Symbol::BoolOp(op)) => {
             let b = eval(stack)?;
             let a = eval(stack)?;
 
             Ok(if op == "-a" { a && b } else { a || b })
         }
-        None => Ok(false),
         _ => Err("expected value".to_string()),
     }
 }
@@ -287,7 +289,7 @@ enum PathCondition {
 }
 
 #[cfg(not(windows))]
-fn path(path: &OsStr, condition: PathCondition) -> bool {
+fn path(path: &OsStr, condition: &PathCondition) -> bool {
     use std::fs::{self, Metadata};
     use std::os::unix::fs::{FileTypeExt, MetadataExt};
 
@@ -329,7 +331,7 @@ fn path(path: &OsStr, condition: PathCondition) -> bool {
         }
     };
 
-    let metadata = if condition == PathCondition::SymLink {
+    let metadata = if condition == &PathCondition::SymLink {
         fs::symlink_metadata(path)
     } else {
         fs::metadata(path)
@@ -366,7 +368,7 @@ fn path(path: &OsStr, condition: PathCondition) -> bool {
 }
 
 #[cfg(windows)]
-fn path(path: &OsStr, condition: PathCondition) -> bool {
+fn path(path: &OsStr, condition: &PathCondition) -> bool {
     use std::fs::metadata;
 
     let stat = match metadata(path) {
diff --git a/src/uu/timeout/Cargo.toml b/src/uu/timeout/Cargo.toml
index 13afe8435..fa515913c 100644
--- a/src/uu/timeout/Cargo.toml
+++ b/src/uu/timeout/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_timeout"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "timeout ~ (uutils) run COMMAND with a DURATION time limit"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/timeout"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/timeout"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,12 +15,10 @@ edition = "2018"
 path = "src/timeout.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
-nix = "0.20.0"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["process", "signals"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
+nix = "0.23.1"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["process", "signals"] }
 
 [[bin]]
 name = "timeout"
diff --git a/src/uu/timeout/LICENSE b/src/uu/timeout/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/timeout/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/timeout/src/main.rs b/src/uu/timeout/src/main.rs
index 2479f91c1..e7d3224ff 100644
--- a/src/uu/timeout/src/main.rs
+++ b/src/uu/timeout/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_timeout);
+uucore::bin!(uu_timeout);
diff --git a/src/uu/timeout/src/status.rs b/src/uu/timeout/src/status.rs
new file mode 100644
index 000000000..9a8558954
--- /dev/null
+++ b/src/uu/timeout/src/status.rs
@@ -0,0 +1,51 @@
+//  * 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.
+//! Exit status codes produced by `timeout`.
+use std::convert::From;
+use uucore::error::UError;
+
+/// Enumerates the exit statuses produced by `timeout`.
+///
+/// Use [`Into::into`] (or [`From::from`]) to convert an enumeration
+/// member into a numeric status code. You can also convert into a
+/// [`UError`].
+///
+/// # Examples
+///
+/// Convert into an [`i32`]:
+///
+/// ```rust,ignore
+/// assert_eq!(i32::from(ExitStatus::CommandTimedOut), 124);
+/// ```
+pub(crate) enum ExitStatus {
+    /// When the child process times out and `--preserve-status` is not specified.
+    CommandTimedOut,
+
+    /// When `timeout` itself fails.
+    TimeoutFailed,
+
+    /// When a signal is sent to the child process or `timeout` itself.
+    SignalSent(usize),
+
+    /// When there is a failure while waiting for the child process to terminate.
+    WaitingFailed,
+}
+
+impl From<ExitStatus> for i32 {
+    fn from(exit_status: ExitStatus) -> Self {
+        match exit_status {
+            ExitStatus::CommandTimedOut => 124,
+            ExitStatus::TimeoutFailed => 125,
+            ExitStatus::SignalSent(s) => 128 + s as Self,
+            ExitStatus::WaitingFailed => 124,
+        }
+    }
+}
+
+impl From<ExitStatus> for Box<dyn UError> {
+    fn from(exit_status: ExitStatus) -> Self {
+        Box::from(i32::from(exit_status))
+    }
+}
diff --git a/src/uu/timeout/src/timeout.rs b/src/uu/timeout/src/timeout.rs
index f686dde3b..8374c124c 100644
--- a/src/uu/timeout/src/timeout.rs
+++ b/src/uu/timeout/src/timeout.rs
@@ -6,31 +6,26 @@
 //  * file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) tstr sigstr cmdname setpgid sigchld
+mod status;
 
 #[macro_use]
 extern crate uucore;
 
 extern crate clap;
 
-use clap::{crate_version, App, AppSettings, Arg};
+use crate::status::ExitStatus;
+use clap::{crate_version, Arg, Command};
 use std::io::ErrorKind;
-use std::process::{Command, Stdio};
+use std::process::{self, Child, Stdio};
 use std::time::Duration;
 use uucore::display::Quotable;
+use uucore::error::{UResult, USimpleError, UUsageError};
 use uucore::process::ChildExt;
 use uucore::signals::{signal_by_name_or_value, signal_name_by_value};
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "Start COMMAND, and kill it if still running after DURATION.";
-
-fn usage() -> String {
-    format!(
-        "{0} [OPTION] DURATION COMMAND...",
-        uucore::execution_phrase()
-    )
-}
-
-const ERR_EXIT_STATUS: i32 = 125;
+const USAGE: &str = "{} [OPTION] DURATION COMMAND...";
 
 pub mod options {
     pub static FOREGROUND: &str = "foreground";
@@ -56,13 +51,16 @@ struct Config {
 }
 
 impl Config {
-    fn from(options: clap::ArgMatches) -> Config {
+    fn from(options: &clap::ArgMatches) -> UResult<Self> {
         let signal = match options.value_of(options::SIGNAL) {
             Some(signal_) => {
                 let signal_result = signal_by_name_or_value(signal_);
                 match signal_result {
                     None => {
-                        unreachable!("invalid signal {}", signal_.quote());
+                        return Err(UUsageError::new(
+                            ExitStatus::TimeoutFailed.into(),
+                            format!("{}: invalid signal", signal_.quote()),
+                        ))
                     }
                     Some(signal_value) => signal_value,
                 }
@@ -70,12 +68,19 @@ impl Config {
             _ => uucore::signals::signal_by_name_or_value("TERM").unwrap(),
         };
 
-        let kill_after = options
-            .value_of(options::KILL_AFTER)
-            .map(|time| uucore::parse_time::from_str(time).unwrap());
+        let kill_after = match options.value_of(options::KILL_AFTER) {
+            None => None,
+            Some(kill_after) => match uucore::parse_time::from_str(kill_after) {
+                Ok(k) => Some(k),
+                Err(err) => return Err(UUsageError::new(ExitStatus::TimeoutFailed.into(), err)),
+            },
+        };
 
-        let duration: Duration =
-            uucore::parse_time::from_str(options.value_of(options::DURATION).unwrap()).unwrap();
+        let duration =
+            match uucore::parse_time::from_str(options.value_of(options::DURATION).unwrap()) {
+                Ok(duration) => duration,
+                Err(err) => return Err(UUsageError::new(ExitStatus::TimeoutFailed.into(), err)),
+            };
 
         let preserve_status: bool = options.is_present(options::PRESERVE_STATUS);
         let foreground = options.is_present(options::FOREGROUND);
@@ -87,7 +92,7 @@ impl Config {
             .map(String::from)
             .collect::<Vec<_>>();
 
-        Config {
+        Ok(Self {
             foreground,
             kill_after,
             signal,
@@ -95,22 +100,21 @@ impl Config {
             preserve_status,
             verbose,
             command,
-        }
+        })
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
 
-    let usage = usage();
+    let command = uu_app();
 
-    let app = uu_app().usage(&usage[..]);
+    let matches = command.get_matches_from(args);
 
-    let matches = app.get_matches_from(args);
-
-    let config = Config::from(matches);
+    let config = Config::from(&matches)?;
     timeout(
         &config.command,
         config.duration,
@@ -122,49 +126,53 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     )
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new("timeout")
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new("timeout")
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
         .arg(
-            Arg::with_name(options::FOREGROUND)
+            Arg::new(options::FOREGROUND)
                 .long(options::FOREGROUND)
                 .help("when not running timeout directly from a shell prompt, allow COMMAND to read from the TTY and get TTY signals; in this mode, children of COMMAND will not be timed out")
         )
         .arg(
-            Arg::with_name(options::KILL_AFTER)
-                .short("k")
+            Arg::new(options::KILL_AFTER)
+                .long(options::KILL_AFTER)
+                .short('k')
+                .help("also send a KILL signal if COMMAND is still running this long after the initial signal was sent")
                 .takes_value(true))
         .arg(
-            Arg::with_name(options::PRESERVE_STATUS)
+            Arg::new(options::PRESERVE_STATUS)
                 .long(options::PRESERVE_STATUS)
                 .help("exit with the same status as COMMAND, even when the command times out")
         )
         .arg(
-            Arg::with_name(options::SIGNAL)
-                .short("s")
+            Arg::new(options::SIGNAL)
+                .short('s')
                 .long(options::SIGNAL)
                 .help("specify the signal to be sent on timeout; SIGNAL may be a name like 'HUP' or a number; see 'kill -l' for a list of signals")
                 .takes_value(true)
         )
         .arg(
-            Arg::with_name(options::VERBOSE)
-              .short("v")
+            Arg::new(options::VERBOSE)
+              .short('v')
               .long(options::VERBOSE)
               .help("diagnose to stderr any signal sent upon timeout")
         )
         .arg(
-            Arg::with_name(options::DURATION)
+            Arg::new(options::DURATION)
                 .index(1)
                 .required(true)
         )
         .arg(
-            Arg::with_name(options::COMMAND)
+            Arg::new(options::COMMAND)
                 .index(2)
                 .required(true)
-                .multiple(true)
+                .multiple_occurrences(true)
         )
-        .setting(AppSettings::TrailingVarArg)
+        .trailing_var_arg(true)
+        .infer_long_args(true)
 }
 
 /// Remove pre-existing SIGCHLD handlers that would make waiting for the child's exit code fail.
@@ -178,6 +186,60 @@ fn unblock_sigchld() {
     }
 }
 
+/// Report that a signal is being sent if the verbose flag is set.
+fn report_if_verbose(signal: usize, cmd: &str, verbose: bool) {
+    if verbose {
+        let s = signal_name_by_value(signal).unwrap();
+        show_error!("sending signal {} to command {}", s, cmd.quote());
+    }
+}
+
+/// Wait for a child process and send a kill signal if it does not terminate.
+///
+/// This function waits for the child `process` for the time period
+/// given by `duration`. If the child process does not terminate
+/// within that time, we send the `SIGKILL` signal to it. If `verbose`
+/// is `true`, then a message is printed to `stderr` when that
+/// happens.
+///
+/// If the child process terminates within the given time period and
+/// `preserve_status` is `true`, then the status code of the child
+/// process is returned. If the child process terminates within the
+/// given time period and `preserve_status` is `false`, then 124 is
+/// returned. If the child does not terminate within the time period,
+/// then 137 is returned. Finally, if there is an error while waiting
+/// for the child process to terminate, then 124 is returned.
+///
+/// # Errors
+///
+/// If there is a problem sending the `SIGKILL` signal or waiting for
+/// the process after that signal is sent.
+fn wait_or_kill_process(
+    mut process: Child,
+    cmd: &str,
+    duration: Duration,
+    preserve_status: bool,
+    verbose: bool,
+) -> std::io::Result<i32> {
+    match process.wait_or_timeout(duration) {
+        Ok(Some(status)) => {
+            if preserve_status {
+                Ok(status.code().unwrap_or_else(|| status.signal().unwrap()))
+            } else {
+                Ok(ExitStatus::TimeoutFailed.into())
+            }
+        }
+        Ok(None) => {
+            let signal = signal_by_name_or_value("KILL").unwrap();
+            report_if_verbose(signal, cmd, verbose);
+            process.send_signal(signal)?;
+            process.wait()?;
+            Ok(ExitStatus::SignalSent(signal).into())
+        }
+        Err(_) => Ok(ExitStatus::WaitingFailed.into()),
+    }
+}
+
 /// TODO: Improve exit codes, and make them consistent with the GNU Coreutils exit codes.
 
 fn timeout(
@@ -188,72 +250,79 @@ fn timeout(
     foreground: bool,
     preserve_status: bool,
     verbose: bool,
-) -> i32 {
+) -> UResult<()> {
     if !foreground {
         unsafe { libc::setpgid(0, 0) };
     }
-    let mut process = match Command::new(&cmd[0])
+    let mut process = process::Command::new(&cmd[0])
         .args(&cmd[1..])
         .stdin(Stdio::inherit())
         .stdout(Stdio::inherit())
         .stderr(Stdio::inherit())
         .spawn()
-    {
-        Ok(p) => p,
-        Err(err) => {
-            show_error!("failed to execute process: {}", err);
-            if err.kind() == ErrorKind::NotFound {
+        .map_err(|err| {
+            let status_code = if err.kind() == ErrorKind::NotFound {
                 // FIXME: not sure which to use
-                return 127;
+                127
             } else {
                 // FIXME: this may not be 100% correct...
-                return 126;
-            }
-        }
-    };
+                126
+            };
+            USimpleError::new(status_code, format!("failed to execute process: {}", err))
+        })?;
     unblock_sigchld();
+    // Wait for the child process for the specified time period.
+    //
+    // If the process exits within the specified time period (the
+    // `Ok(Some(_))` arm), then return the appropriate status code.
+    //
+    // If the process does not exit within that time (the `Ok(None)`
+    // arm) and `kill_after` is specified, then try sending `SIGKILL`.
+    //
+    // TODO The structure of this block is extremely similar to the
+    // structure of `wait_or_kill_process()`. They can probably be
+    // refactored into some common function.
     match process.wait_or_timeout(duration) {
-        Ok(Some(status)) => status.code().unwrap_or_else(|| status.signal().unwrap()),
+        Ok(Some(status)) => Err(status
+            .code()
+            .unwrap_or_else(|| status.signal().unwrap())
+            .into()),
         Ok(None) => {
-            if verbose {
-                show_error!(
-                    "sending signal {} to command {}",
-                    signal_name_by_value(signal).unwrap(),
-                    cmd[0].quote()
-                );
-            }
-            crash_if_err!(ERR_EXIT_STATUS, process.send_signal(signal));
-            if let Some(kill_after) = kill_after {
-                match process.wait_or_timeout(kill_after) {
-                    Ok(Some(status)) => {
-                        if preserve_status {
-                            status.code().unwrap_or_else(|| status.signal().unwrap())
-                        } else {
-                            124
-                        }
+            report_if_verbose(signal, &cmd[0], verbose);
+            process.send_signal(signal)?;
+            match kill_after {
+                None => {
+                    if preserve_status {
+                        Err(ExitStatus::SignalSent(signal).into())
+                    } else {
+                        Err(ExitStatus::CommandTimedOut.into())
+                    }
+                }
+                Some(kill_after) => {
+                    match wait_or_kill_process(
+                        process,
+                        &cmd[0],
+                        kill_after,
+                        preserve_status,
+                        verbose,
+                    ) {
+                        Ok(status) => Err(status.into()),
+                        Err(e) => Err(USimpleError::new(
+                            ExitStatus::TimeoutFailed.into(),
+                            format!("{}", e),
+                        )),
                     }
-                    Ok(None) => {
-                        if verbose {
-                            show_error!("sending signal KILL to command {}", cmd[0].quote());
-                        }
-                        crash_if_err!(
-                            ERR_EXIT_STATUS,
-                            process.send_signal(
-                                uucore::signals::signal_by_name_or_value("KILL").unwrap()
-                            )
-                        );
-                        crash_if_err!(ERR_EXIT_STATUS, process.wait());
-                        137
-                    }
-                    Err(_) => 124,
                 }
-            } else {
-                124
             }
         }
         Err(_) => {
-            crash_if_err!(ERR_EXIT_STATUS, process.send_signal(signal));
-            ERR_EXIT_STATUS
+            // We're going to return ERR_EXIT_STATUS regardless of
+            // whether `send_signal()` succeeds or fails, so just
+            // ignore the return value.
+            process.send_signal(signal).map_err(|e| {
+                USimpleError::new(ExitStatus::TimeoutFailed.into(), format!("{}", e))
+            })?;
+            Err(ExitStatus::TimeoutFailed.into())
         }
     }
 }
diff --git a/src/uu/touch/Cargo.toml b/src/uu/touch/Cargo.toml
index b21e2dfa3..521c4c151 100644
--- a/src/uu/touch/Cargo.toml
+++ b/src/uu/touch/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_touch"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "touch ~ (uutils) change FILE timestamps"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/touch"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/touch"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -16,10 +16,12 @@ path = "src/touch.rs"
 
 [dependencies]
 filetime = "0.2.1"
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 time = "0.1.40"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["libc"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["libc"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3" }
 
 [[bin]]
 name = "touch"
diff --git a/src/uu/touch/LICENSE b/src/uu/touch/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/touch/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/touch/src/main.rs b/src/uu/touch/src/main.rs
index e8a2729a2..33b77a241 100644
--- a/src/uu/touch/src/main.rs
+++ b/src/uu/touch/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_touch);
+uucore::bin!(uu_touch);
diff --git a/src/uu/touch/src/touch.rs b/src/uu/touch/src/touch.rs
index 6997def09..864917574 100644
--- a/src/uu/touch/src/touch.rs
+++ b/src/uu/touch/src/touch.rs
@@ -6,21 +6,23 @@
 // For the full copyright and license information, please view the LICENSE file
 // that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) filetime strptime utcoff strs datetime MMDDhhmm clapv
+// spell-checker:ignore (ToDO) filetime strptime utcoff strs datetime MMDDhhmm clapv PWSTR lpszfilepath hresult
 
 pub extern crate filetime;
 
 #[macro_use]
 extern crate uucore;
 
-use clap::{crate_version, App, Arg, ArgGroup};
+use clap::{crate_version, Arg, ArgGroup, Command};
 use filetime::*;
 use std::fs::{self, File};
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::format_usage;
 
 static ABOUT: &str = "Update the access and modification times of each FILE to the current time.";
+const USAGE: &str = "{} [OPTION]... [USER]";
 pub mod options {
     // Both SOURCES and sources are needed as we need to be able to refer to the ArgGroup.
     pub static SOURCES: &str = "sources";
@@ -29,6 +31,7 @@ pub mod options {
         pub static REFERENCE: &str = "reference";
         pub static CURRENT: &str = "current";
     }
+    pub static HELP: &str = "help";
     pub static ACCESS: &str = "access";
     pub static MODIFICATION: &str = "modification";
     pub static NO_CREATE: &str = "no-create";
@@ -48,17 +51,17 @@ fn local_tm_to_filetime(tm: time::Tm) -> FileTime {
     FileTime::from_unix_time(ts.sec as i64, ts.nsec as u32)
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [USER]", uucore::execution_phrase())
-}
-
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
+    let matches = uu_app().get_matches_from(args);
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
-
-    let files = matches.values_of_os(ARG_FILES).unwrap();
+    let files = matches.values_of_os(ARG_FILES).ok_or_else(|| {
+        USimpleError::new(
+            1,
+            r##"missing file operand
+Try 'touch --help' for more information."##,
+        )
+    })?;
 
     let (mut atime, mut mtime) =
         if let Some(reference) = matches.value_of_os(options::sources::REFERENCE) {
@@ -75,10 +78,28 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         };
 
     for filename in files {
-        let path = Path::new(filename);
+        // FIXME: find a way to avoid having to clone the path
+        let pathbuf = if filename == "-" {
+            pathbuf_from_stdout()?
+        } else {
+            PathBuf::from(filename)
+        };
+
+        let path = pathbuf.as_path();
+
         if !path.exists() {
-            // no-dereference included here for compatibility
-            if matches.is_present(options::NO_CREATE) || matches.is_present(options::NO_DEREF) {
+            if matches.is_present(options::NO_CREATE) {
+                continue;
+            }
+
+            if matches.is_present(options::NO_DEREF) {
+                show!(USimpleError::new(
+                    1,
+                    format!(
+                        "setting times of {}: No such file or directory",
+                        filename.quote()
+                    )
+                ));
                 continue;
             }
 
@@ -129,43 +150,50 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::ACCESS)
-                .short("a")
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information."),
+        )
+        .arg(
+            Arg::new(options::ACCESS)
+                .short('a')
                 .help("change only the access time"),
         )
         .arg(
-            Arg::with_name(options::sources::CURRENT)
-                .short("t")
+            Arg::new(options::sources::CURRENT)
+                .short('t')
                 .help("use [[CC]YY]MMDDhhmm[.ss] instead of the current time")
                 .value_name("STAMP")
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(options::sources::DATE)
-                .short("d")
+            Arg::new(options::sources::DATE)
+                .short('d')
                 .long(options::sources::DATE)
                 .help("parse argument and use it instead of current time")
                 .value_name("STRING"),
         )
         .arg(
-            Arg::with_name(options::MODIFICATION)
-                .short("m")
+            Arg::new(options::MODIFICATION)
+                .short('m')
                 .help("change only the modification time"),
         )
         .arg(
-            Arg::with_name(options::NO_CREATE)
-                .short("c")
+            Arg::new(options::NO_CREATE)
+                .short('c')
                 .long(options::NO_CREATE)
                 .help("do not create any files"),
         )
         .arg(
-            Arg::with_name(options::NO_DEREF)
-                .short("h")
+            Arg::new(options::NO_DEREF)
+                .short('h')
                 .long(options::NO_DEREF)
                 .help(
                     "affect each symbolic link instead of any referenced file \
@@ -173,15 +201,15 @@ pub fn uu_app() -> App<'static, 'static> {
                 ),
         )
         .arg(
-            Arg::with_name(options::sources::REFERENCE)
-                .short("r")
+            Arg::new(options::sources::REFERENCE)
+                .short('r')
                 .long(options::sources::REFERENCE)
-                .alias("ref") // clapv3
                 .help("use this file's times instead of the current time")
-                .value_name("FILE"),
+                .value_name("FILE")
+                .allow_invalid_utf8(true),
         )
         .arg(
-            Arg::with_name(options::TIME)
+            Arg::new(options::TIME)
                 .long(options::TIME)
                 .help(
                     "change only the specified time: \"access\", \"atime\", or \
@@ -193,12 +221,13 @@ pub fn uu_app() -> App<'static, 'static> {
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name(ARG_FILES)
-                .multiple(true)
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
                 .takes_value(true)
-                .min_values(1),
+                .min_values(1)
+                .allow_invalid_utf8(true),
         )
-        .group(ArgGroup::with_name(options::SOURCES).args(&[
+        .group(ArgGroup::new(options::SOURCES).args(&[
             options::sources::CURRENT,
             options::sources::DATE,
             options::sources::REFERENCE,
@@ -284,3 +313,89 @@ fn parse_timestamp(s: &str) -> UResult<FileTime> {
 
     Ok(ft)
 }
+
+// TODO: this may be a good candidate to put in fsext.rs
+/// Returns a PathBuf to stdout.
+///
+/// On Windows, uses GetFinalPathNameByHandleW to attempt to get the path
+/// from the stdout handle.
+fn pathbuf_from_stdout() -> UResult<PathBuf> {
+    #[cfg(unix)]
+    {
+        Ok(PathBuf::from("/dev/stdout"))
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::prelude::AsRawHandle;
+        use winapi::shared::minwindef::{DWORD, MAX_PATH};
+        use winapi::shared::winerror::{
+            ERROR_INVALID_PARAMETER, ERROR_NOT_ENOUGH_MEMORY, ERROR_PATH_NOT_FOUND,
+        };
+        use winapi::um::errhandlingapi::GetLastError;
+        use winapi::um::fileapi::GetFinalPathNameByHandleW;
+        use winapi::um::winnt::WCHAR;
+
+        let handle = std::io::stdout().lock().as_raw_handle();
+        let mut file_path_buffer: [WCHAR; MAX_PATH as usize] = [0; MAX_PATH as usize];
+
+        // Couldn't find this in winapi
+        const FILE_NAME_OPENED: DWORD = 0x8;
+
+        // https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlea#examples
+        // SAFETY: We transmute the handle to be able to cast *mut c_void into a
+        // HANDLE (i32) so rustc will let us call GetFinalPathNameByHandleW. The
+        // reference example code for GetFinalPathNameByHandleW implies that
+        // it is safe for us to leave lpszfilepath uninitialized, so long as
+        // the buffer size is correct. We know the buffer size (MAX_PATH) at
+        // compile time. MAX_PATH is a small number (260) so we can cast it
+        // to a u32.
+        let ret = unsafe {
+            GetFinalPathNameByHandleW(
+                std::mem::transmute(handle),
+                file_path_buffer.as_mut_ptr(),
+                file_path_buffer.len() as u32,
+                FILE_NAME_OPENED,
+            )
+        };
+
+        let buffer_size = match ret {
+            ERROR_PATH_NOT_FOUND | ERROR_NOT_ENOUGH_MEMORY | ERROR_INVALID_PARAMETER => {
+                return Err(USimpleError::new(
+                    1,
+                    format!("GetFinalPathNameByHandleW failed with code {}", ret),
+                ))
+            }
+            e if e == 0 => {
+                return Err(USimpleError::new(
+                    1,
+                    format!(
+                        "GetFinalPathNameByHandleW failed with code {}",
+                        // SAFETY: GetLastError is thread-safe and has no documented memory unsafety.
+                        unsafe { GetLastError() }
+                    ),
+                ));
+            }
+            e => e as usize,
+        };
+
+        // Don't include the null terminator
+        Ok(String::from_utf16(&file_path_buffer[0..buffer_size])
+            .map_err(|e| USimpleError::new(1, e.to_string()))?
+            .into())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(windows)]
+    #[test]
+    fn test_get_pathbuf_from_stdout_fails_if_stdout_is_not_a_file() {
+        // We can trigger an error by not setting stdout to anything (will
+        // fail with code 1)
+        assert!(super::pathbuf_from_stdout()
+            .err()
+            .expect("pathbuf_from_stdout should have failed")
+            .to_string()
+            .contains("GetFinalPathNameByHandleW failed with code 1"));
+    }
+}
diff --git a/src/uu/tr/Cargo.toml b/src/uu/tr/Cargo.toml
index 8792938a9..cabf74556 100644
--- a/src/uu/tr/Cargo.toml
+++ b/src/uu/tr/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_tr"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tr ~ (uutils) translate characters within input and display"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/tr"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tr"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,16 +15,10 @@ edition = "2018"
 path = "src/tr.rs"
 
 [dependencies]
-bit-set = "0.5.0"
-fnv = "1.0.5"
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+nom = "7.1.0"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "tr"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/tr/LICENSE b/src/uu/tr/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/tr/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/tr/src/convert.rs b/src/uu/tr/src/convert.rs
new file mode 100644
index 000000000..00656ca49
--- /dev/null
+++ b/src/uu/tr/src/convert.rs
@@ -0,0 +1,36 @@
+//  * 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/expand.rs b/src/uu/tr/src/expand.rs
deleted file mode 100644
index 5d960921e..000000000
--- a/src/uu/tr/src/expand.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-//  * This file is part of the uutils coreutils package.
-//  *
-//  * (c) Michael Gehring <mg@ebfe.org>
-//  * (c) kwantam <kwantam@gmail.com>
-//  *     * 2015-04-28 ~ created `expand` module to eliminate most allocs during setup
-//  *
-//  * For the full copyright and license information, please view the LICENSE
-//  * file that was distributed with this source code.
-
-// spell-checker:ignore (ToDO) allocs slen unesc
-
-use std::char::from_u32;
-use std::cmp::min;
-use std::iter::Peekable;
-use std::ops::RangeInclusive;
-
-/// Parse a backslash escape sequence to the corresponding character. Assumes
-/// the string starts from the character _after_ the `\` and is not empty.
-///
-/// Returns a tuple containing the character and the number of characters
-/// consumed from the input. The alphabetic escape sequences consume 1
-/// character; octal escape sequences consume 1 to 3 octal digits.
-#[inline]
-fn parse_sequence(s: &str) -> (char, usize) {
-    let mut s = s.chars();
-    let c = s.next().expect("invalid escape: empty string");
-
-    if ('0'..='7').contains(&c) {
-        let mut v = c.to_digit(8).unwrap();
-        let mut consumed = 1;
-        let bits_per_digit = 3;
-
-        for c in s.take(2) {
-            match c.to_digit(8) {
-                Some(c) => {
-                    v = (v << bits_per_digit) | c;
-                    consumed += 1;
-                }
-                None => break,
-            }
-        }
-
-        (from_u32(v).expect("invalid octal escape"), consumed)
-    } else {
-        (
-            match c {
-                'a' => 0x07u8 as char,
-                'b' => 0x08u8 as char,
-                'f' => 0x0cu8 as char,
-                'v' => 0x0bu8 as char,
-                'n' => '\n',
-                'r' => '\r',
-                't' => '\t',
-                c => c,
-            },
-            1,
-        )
-    }
-}
-
-struct Unescape<'a> {
-    string: &'a str,
-}
-
-impl<'a> Iterator for Unescape<'a> {
-    type Item = char;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let slen = self.string.len();
-        (min(slen, 1), None)
-    }
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.string.is_empty() {
-            return None;
-        }
-
-        // is the next character an escape?
-        let (ret, idx) = match self.string.chars().next().unwrap() {
-            '\\' if self.string.len() > 1 => {
-                // yes---it's \ and it's not the last char in a string
-                // we know that \ is 1 byte long so we can index into the string safely
-                let (c, consumed) = parse_sequence(&self.string[1..]);
-
-                (Some(c), 1 + consumed)
-            }
-            c => (Some(c), c.len_utf8()), // not an escape char
-        };
-
-        self.string = &self.string[idx..]; // advance the pointer to the next char
-        ret
-    }
-}
-
-pub struct ExpandSet<'a> {
-    range: RangeInclusive<u32>,
-    unesc: Peekable<Unescape<'a>>,
-}
-
-impl<'a> Iterator for ExpandSet<'a> {
-    type Item = char;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.unesc.size_hint()
-    }
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        // while the Range has elements, try to return chars from it
-        // but make sure that they actually turn out to be Chars!
-        for n in &mut self.range {
-            if let Some(c) = from_u32(n) {
-                return Some(c);
-            }
-        }
-
-        if let Some(first) = self.unesc.next() {
-            // peek ahead
-            if self.unesc.peek() == Some(&'-') && self.unesc.size_hint().0 > 1 {
-                self.unesc.next(); // this is the '-'
-                let last = self.unesc.next().unwrap(); // this is the end of the range
-
-                {
-                    self.range = first as u32 + 1..=last as u32;
-                }
-            }
-
-            return Some(first); // in any case, return the next char
-        }
-
-        None
-    }
-}
-
-impl<'a> ExpandSet<'a> {
-    #[inline]
-    pub fn new(s: &'a str) -> ExpandSet<'a> {
-        ExpandSet {
-            range: 0..=0,
-            unesc: Unescape { string: s }.peekable(),
-        }
-    }
-}
diff --git a/src/uu/tr/src/main.rs b/src/uu/tr/src/main.rs
index 9118c3628..7365a22ad 100644
--- a/src/uu/tr/src/main.rs
+++ b/src/uu/tr/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_tr);
+uucore::bin!(uu_tr);
diff --git a/src/uu/tr/src/operation.rs b/src/uu/tr/src/operation.rs
new file mode 100644
index 000000000..2c88758c5
--- /dev/null
+++ b/src/uu/tr/src/operation.rs
@@ -0,0 +1,553 @@
+//  * 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 Alnum Punct Xdigit alnum punct xdigit cntrl
+
+use nom::{
+    branch::alt,
+    bytes::complete::tag,
+    character::complete::{anychar, digit1},
+    combinator::{map, peek, value},
+    multi::many0,
+    sequence::{delimited, preceded, separated_pair},
+    IResult,
+};
+use std::{
+    collections::{HashMap, HashSet},
+    error::Error,
+    fmt::{Debug, Display},
+    io::{BufRead, Write},
+};
+use uucore::error::UError;
+
+use crate::unicode_table;
+
+#[derive(Debug, Clone)]
+pub enum BadSequence {
+    MissingCharClassName,
+    MissingEquivalentClassChar,
+    MultipleCharRepeatInSet2,
+    CharRepeatInSet1,
+    InvalidRepeatCount(String),
+    EmptySet2WhenNotTruncatingSet1,
+}
+
+impl Display for BadSequence {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::MissingCharClassName => writeln!(f, "missing character class name '[::]'"),
+            Self::MissingEquivalentClassChar => {
+                writeln!(f, "missing equivalence class character '[==]'")
+            }
+            Self::MultipleCharRepeatInSet2 => {
+                writeln!(f, "only one [c*] repeat construct may appear in string2")
+            }
+            Self::CharRepeatInSet1 => {
+                writeln!(f, "the [c*] repeat construct may not appear in string1")
+            }
+            Self::InvalidRepeatCount(count) => {
+                writeln!(f, "invalid repeat count '{}' in [c*n] construct", count)
+            }
+            Self::EmptySet2WhenNotTruncatingSet1 => {
+                writeln!(f, "when not truncating set1, string2 must be non-empty")
+            }
+        }
+    }
+}
+
+impl Error for BadSequence {}
+impl UError for BadSequence {}
+
+#[derive(Debug, Clone, Copy)]
+pub enum Sequence {
+    Char(char),
+    CharRange(u32, u32),
+    CharStar(char),
+    CharRepeat(char, usize),
+    Alnum,
+    Alpha,
+    Blank,
+    Control,
+    Digit,
+    Graph,
+    Lower,
+    Print,
+    Punct,
+    Space,
+    Upper,
+    Xdigit,
+}
+
+impl Sequence {
+    pub fn flatten(&self) -> Box<dyn Iterator<Item = char>> {
+        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::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::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::Graph => Box::new(
+                (48..=57) // digit
+                    .chain(65..=90) // uppercase
+                    .chain(97..=122) // lowercase
+                    // punctuations
+                    .chain(33..=47)
+                    .chain(58..=64)
+                    .chain(91..=96)
+                    .chain(123..=126)
+                    .chain(std::iter::once(32)) // space
+                    .flat_map(std::char::from_u32),
+            ),
+            Self::Lower => Box::new('a'..='z'),
+            Self::Print => Box::new(
+                (48..=57) // digit
+                    .chain(65..=90) // uppercase
+                    .chain(97..=122) // lowercase
+                    // punctuations
+                    .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),
+            ),
+            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')),
+        }
+    }
+
+    // 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,
+        truncate_set1_flag: bool,
+    ) -> Result<(Vec<char>, Vec<char>), BadSequence> {
+        let set1 = Self::from_str(set1_str)?;
+        let set2 = Self::from_str(set2_str)?;
+
+        let is_char_star = |s: &&Self| -> bool { matches!(s, Sequence::CharStar(_)) };
+        let set1_star_count = set1.iter().filter(is_char_star).count();
+        if set1_star_count == 0 {
+            let set2_star_count = set2.iter().filter(is_char_star).count();
+            if set2_star_count < 2 {
+                let char_star = set2.iter().find_map(|s| match s {
+                    Sequence::CharStar(c) => Some(c),
+                    _ => None,
+                });
+                let mut partition = set2.as_slice().split(|s| matches!(s, Self::CharStar(_)));
+                let set1_len = set1.iter().flat_map(Self::flatten).count();
+                let set2_len = set2
+                    .iter()
+                    .filter_map(|s| match s {
+                        Sequence::CharStar(_) => None,
+                        r => Some(r),
+                    })
+                    .flat_map(Self::flatten)
+                    .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) {
+                    (None, None) => match char_star {
+                        Some(c) => std::iter::repeat(*c).take(star_compensate_len).collect(),
+                        None => std::iter::empty().collect(),
+                    },
+                    (None, Some(set2_b)) => {
+                        if let Some(c) = char_star {
+                            std::iter::repeat(*c)
+                                .take(star_compensate_len)
+                                .chain(set2_b.iter().flat_map(Self::flatten))
+                                .collect()
+                        } else {
+                            set2_b.iter().flat_map(Self::flatten).collect()
+                        }
+                    }
+                    (Some(set2_a), None) => match char_star {
+                        Some(c) => set2_a
+                            .iter()
+                            .flat_map(Self::flatten)
+                            .chain(std::iter::repeat(*c).take(star_compensate_len))
+                            .collect(),
+                        None => set2_a.iter().flat_map(Self::flatten).collect(),
+                    },
+                    (Some(set2_a), Some(set2_b)) => match char_star {
+                        Some(c) => set2_a
+                            .iter()
+                            .flat_map(Self::flatten)
+                            .chain(std::iter::repeat(*c).take(star_compensate_len))
+                            .chain(set2_b.iter().flat_map(Self::flatten))
+                            .collect(),
+                        None => set2_a
+                            .iter()
+                            .chain(set2_b.iter())
+                            .flat_map(Self::flatten)
+                            .collect(),
+                    },
+                };
+                let mut set1_solved: Vec<char> = set1.iter().flat_map(Self::flatten).collect();
+                if truncate_set1_flag {
+                    set1_solved.truncate(set2_solved.len());
+                }
+                Ok((set1_solved, set2_solved))
+            } else {
+                Err(BadSequence::MultipleCharRepeatInSet2)
+            }
+        } else {
+            Err(BadSequence::CharRepeatInSet1)
+        }
+    }
+}
+
+impl Sequence {
+    pub fn from_str(input: &str) -> Result<Vec<Self>, BadSequence> {
+        many0(alt((
+            Self::parse_char_range,
+            Self::parse_char_star,
+            Self::parse_char_repeat,
+            Self::parse_class,
+            Self::parse_char_equal,
+            // NOTE: This must be the last one
+            map(Self::parse_backslash_or_char, |s| Ok(Self::Char(s))),
+        )))(input)
+        .map(|(_, r)| r)
+        .unwrap()
+        .into_iter()
+        .collect::<Result<Vec<_>, _>>()
+    }
+
+    fn parse_backslash(input: &str) -> IResult<&str, char> {
+        preceded(tag("\\"), anychar)(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,
+                x => x,
+            };
+            (l, c)
+        })
+    }
+
+    fn parse_backslash_or_char(input: &str) -> IResult<&str, char> {
+        alt((Self::parse_backslash, anychar))(input)
+    }
+
+    fn parse_char_range(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+        separated_pair(
+            Self::parse_backslash_or_char,
+            tag("-"),
+            Self::parse_backslash_or_char,
+        )(input)
+        .map(|(l, (a, b))| {
+            (l, {
+                let (start, end) = (u32::from(a), u32::from(b));
+                Ok(Self::CharRange(start, end))
+            })
+        })
+    }
+
+    fn parse_char_star(input: &str) -> IResult<&str, 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>> {
+        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) {
+                    Ok(0) => Ok(Self::CharStar(c)),
+                    Ok(count) => Ok(Self::CharRepeat(c, count)),
+                    Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+                }
+            } else {
+                match cnt_str.parse::<usize>() {
+                    Ok(0) => Ok(Self::CharStar(c)),
+                    Ok(count) => Ok(Self::CharRepeat(c, count)),
+                    Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+                }
+            };
+            (l, result)
+        })
+    }
+
+    fn parse_class(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+        delimited(
+            tag("[:"),
+            alt((
+                map(
+                    alt((
+                        value(Self::Alnum, tag("alnum")),
+                        value(Self::Alpha, tag("alpha")),
+                        value(Self::Blank, tag("blank")),
+                        value(Self::Control, tag("cntrl")),
+                        value(Self::Digit, tag("digit")),
+                        value(Self::Graph, tag("graph")),
+                        value(Self::Lower, tag("lower")),
+                        value(Self::Print, tag("print")),
+                        value(Self::Punct, tag("punct")),
+                        value(Self::Space, tag("space")),
+                        value(Self::Upper, tag("upper")),
+                        value(Self::Xdigit, tag("xdigit")),
+                    )),
+                    Ok,
+                ),
+                value(Err(BadSequence::MissingCharClassName), tag("")),
+            )),
+            tag(":]"),
+        )(input)
+    }
+
+    fn parse_char_equal(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+        delimited(
+            tag("[="),
+            alt((
+                value(
+                    Err(BadSequence::MissingEquivalentClassChar),
+                    peek(tag("=]")),
+                ),
+                map(Self::parse_backslash_or_char, |c| Ok(Self::Char(c))),
+            )),
+            tag("=]"),
+        )(input)
+    }
+}
+
+pub trait SymbolTranslator {
+    fn translate(&mut self, current: char) -> Option<char>;
+}
+
+#[derive(Debug)]
+pub struct DeleteOperation {
+    set: Vec<char>,
+    complement_flag: bool,
+}
+
+impl DeleteOperation {
+    pub fn new(set: Vec<char>, complement_flag: bool) -> Self {
+        Self {
+            set,
+            complement_flag,
+        }
+    }
+}
+
+impl SymbolTranslator for DeleteOperation {
+    fn translate(&mut self, current: char) -> Option<char> {
+        let found = self.set.iter().any(|sequence| sequence.eq(&current));
+        if self.complement_flag == found {
+            Some(current)
+        } else {
+            None
+        }
+    }
+}
+
+pub struct TranslateOperationComplement {
+    iter: u32,
+    set2_iter: usize,
+    set1: Vec<char>,
+    set2: Vec<char>,
+    translation_map: HashMap<char, char>,
+}
+
+impl TranslateOperationComplement {
+    fn new(set1: Vec<char>, set2: Vec<char>) -> Self {
+        Self {
+            iter: 0,
+            set2_iter: 0,
+            set1,
+            set2,
+            translation_map: HashMap::new(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TranslateOperationStandard {
+    translation_map: HashMap<char, char>,
+}
+
+impl TranslateOperationStandard {
+    fn new(set1: Vec<char>, set2: Vec<char>) -> Result<Self, BadSequence> {
+        if let Some(fallback) = set2.last().copied() {
+            Ok(Self {
+                translation_map: set1
+                    .into_iter()
+                    .zip(set2.into_iter().chain(std::iter::repeat(fallback)))
+                    .collect::<HashMap<_, _>>(),
+            })
+        } else if set1.is_empty() && set2.is_empty() {
+            Ok(Self {
+                translation_map: HashMap::new(),
+            })
+        } else {
+            Err(BadSequence::EmptySet2WhenNotTruncatingSet1)
+        }
+    }
+}
+
+pub enum TranslateOperation {
+    Standard(TranslateOperationStandard),
+    Complement(TranslateOperationComplement),
+}
+
+impl TranslateOperation {
+    fn next_complement_char(iter: u32, ignore_list: &[char]) -> (u32, char) {
+        (iter..)
+            .filter_map(std::char::from_u32)
+            .filter(|c| !ignore_list.iter().any(|s| s.eq(c)))
+            .map(|c| (u32::from(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> {
+        if complement {
+            Ok(Self::Complement(TranslateOperationComplement::new(
+                set1, set2,
+            )))
+        } else {
+            Ok(Self::Standard(TranslateOperationStandard::new(set1, set2)?))
+        }
+    }
+}
+
+impl SymbolTranslator for TranslateOperation {
+    fn translate(&mut self, current: char) -> Option<char> {
+        match self {
+            Self::Standard(TranslateOperationStandard { translation_map }) => Some(
+                translation_map
+                    .iter()
+                    .find_map(|(l, r)| if l.eq(&current) { Some(*r) } else { None })
+                    .unwrap_or(current),
+            ),
+            Self::Complement(TranslateOperationComplement {
+                iter,
+                set2_iter,
+                set1,
+                set2,
+                translation_map,
+            }) => {
+                // First, try to see if current char is already mapped
+                // If so, return the mapped char
+                // Else, pop from set2
+                // If we popped something, map the next complement character to this value
+                // If set2 is empty, we just map the current char directly to fallback --- to avoid looping unnecessarily
+                if let Some(c) = set1.iter().find(|c| c.eq(&&current)) {
+                    Some(*c)
+                } else {
+                    while translation_map.get(&current).is_none() {
+                        if let Some(value) = set2.get(*set2_iter) {
+                            let (next_iter, next_key) = Self::next_complement_char(*iter, &*set1);
+                            *iter = next_iter;
+                            *set2_iter = set2_iter.saturating_add(1);
+                            translation_map.insert(next_key, *value);
+                        } else {
+                            translation_map.insert(current, *set2.last().unwrap());
+                        }
+                    }
+                    Some(*translation_map.get(&current).unwrap())
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SqueezeOperation {
+    set1: HashSet<char>,
+    complement: bool,
+    previous: Option<char>,
+}
+
+impl SqueezeOperation {
+    pub fn new(set1: Vec<char>, complement: bool) -> Self {
+        Self {
+            set1: set1.into_iter().collect(),
+            complement,
+            previous: None,
+        }
+    }
+}
+
+impl SymbolTranslator for SqueezeOperation {
+    fn translate(&mut self, current: char) -> Option<char> {
+        if self.complement {
+            let next = if self.set1.contains(&current) {
+                Some(current)
+            } else {
+                match self.previous {
+                    Some(v) => {
+                        if v.eq(&current) {
+                            None
+                        } else {
+                            Some(current)
+                        }
+                    }
+                    None => Some(current),
+                }
+            };
+            self.previous = Some(current);
+            next
+        } else {
+            let next = if self.set1.contains(&current) {
+                match self.previous {
+                    Some(v) if v == current => None,
+                    _ => Some(current),
+                }
+            } else {
+                Some(current)
+            };
+            self.previous = Some(current);
+            next
+        }
+    }
+}
+
+pub fn translate_input<T, R, W>(input: &mut R, output: &mut W, mut translator: T)
+where
+    T: SymbolTranslator,
+    R: BufRead,
+    W: Write,
+{
+    let mut buf = String::new();
+    let mut output_buf = String::new();
+    while let Ok(length) = input.read_line(&mut buf) {
+        if length == 0 {
+            break;
+        } else {
+            let filtered = buf.chars().filter_map(|c| translator.translate(c));
+            output_buf.extend(filtered);
+            output.write_all(output_buf.as_bytes()).unwrap();
+        }
+        buf.clear();
+        output_buf.clear();
+    }
+}
diff --git a/src/uu/tr/src/tr.rs b/src/uu/tr/src/tr.rs
index fbc4bab9b..dd8edc518 100644
--- a/src/uu/tr/src/tr.rs
+++ b/src/uu/tr/src/tr.rs
@@ -1,281 +1,86 @@
 //  * This file is part of the uutils coreutils package.
 //  *
-//  * (c) Michael Gehring <mg@ebfe.org>
-//  * (c) kwantam <kwantam@gmail.com>
-//  *     * 2015-04-28 ~ created `expand` module to eliminate most allocs during setup
-//  * (c) Sergey "Shnatsel" Davidoff <shnatsel@gmail.com>
-//  *
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) allocs bset dflag cflag sflag tflag
 
-#[macro_use]
-extern crate uucore;
+extern crate nom;
 
-mod expand;
+mod convert;
+mod operation;
+mod unicode_table;
 
-use bit_set::BitSet;
-use clap::{crate_version, App, Arg};
-use fnv::FnvHashMap;
-use std::io::{stdin, stdout, BufRead, BufWriter, Write};
+use clap::{crate_version, Arg, Command};
+use nom::AsBytes;
+use operation::{translate_input, Sequence, SqueezeOperation, TranslateOperation};
+use std::io::{stdin, stdout, BufReader, BufWriter};
+use uucore::{format_usage, show};
 
-use crate::expand::ExpandSet;
+use crate::operation::DeleteOperation;
+use uucore::error::{UResult, USimpleError, UUsageError};
 use uucore::{display::Quotable, InvalidEncodingHandling};
 
 static ABOUT: &str = "translate or delete characters";
-
-const BUFFER_LEN: usize = 1024;
+const USAGE: &str = "{} [OPTION]... SET1 [SET2]";
 
 mod options {
     pub const COMPLEMENT: &str = "complement";
     pub const DELETE: &str = "delete";
     pub const SQUEEZE: &str = "squeeze-repeats";
-    pub const TRUNCATE: &str = "truncate";
+    pub const TRUNCATE_SET1: &str = "truncate-set1";
     pub const SETS: &str = "sets";
 }
 
-trait SymbolTranslator {
-    fn translate(&self, c: char, prev_c: char) -> Option<char>;
-}
-
-struct DeleteOperation {
-    bset: BitSet,
-    complement: bool,
-}
-
-impl DeleteOperation {
-    fn new(set: ExpandSet, complement: bool) -> DeleteOperation {
-        DeleteOperation {
-            bset: set.map(|c| c as usize).collect(),
-            complement,
-        }
-    }
-}
-
-impl SymbolTranslator for DeleteOperation {
-    fn translate(&self, c: char, _prev_c: char) -> Option<char> {
-        let uc = c as usize;
-        if self.complement == self.bset.contains(uc) {
-            Some(c)
-        } else {
-            None
-        }
-    }
-}
-
-struct SqueezeOperation {
-    squeeze_set: BitSet,
-    complement: bool,
-}
-
-impl SqueezeOperation {
-    fn new(squeeze_set: ExpandSet, complement: bool) -> SqueezeOperation {
-        SqueezeOperation {
-            squeeze_set: squeeze_set.map(|c| c as usize).collect(),
-            complement,
-        }
-    }
-}
-
-impl SymbolTranslator for SqueezeOperation {
-    fn translate(&self, c: char, prev_c: char) -> Option<char> {
-        if prev_c == c && self.complement != self.squeeze_set.contains(c as usize) {
-            None
-        } else {
-            Some(c)
-        }
-    }
-}
-
-struct DeleteAndSqueezeOperation {
-    delete_set: BitSet,
-    squeeze_set: BitSet,
-    complement: bool,
-}
-
-impl DeleteAndSqueezeOperation {
-    fn new(
-        delete_set: ExpandSet,
-        squeeze_set: ExpandSet,
-        complement: bool,
-    ) -> DeleteAndSqueezeOperation {
-        DeleteAndSqueezeOperation {
-            delete_set: delete_set.map(|c| c as usize).collect(),
-            squeeze_set: squeeze_set.map(|c| c as usize).collect(),
-            complement,
-        }
-    }
-}
-
-impl SymbolTranslator for DeleteAndSqueezeOperation {
-    fn translate(&self, c: char, prev_c: char) -> Option<char> {
-        if self.complement != self.delete_set.contains(c as usize)
-            || prev_c == c && self.squeeze_set.contains(c as usize)
-        {
-            None
-        } else {
-            Some(c)
-        }
-    }
-}
-
-struct TranslateOperation {
-    translate_map: FnvHashMap<usize, char>,
-    complement: bool,
-    s2_last: char,
-}
-
-impl TranslateOperation {
-    fn new(
-        set1: ExpandSet,
-        set2: &mut ExpandSet,
-        truncate: bool,
-        complement: bool,
-    ) -> TranslateOperation {
-        let mut map = FnvHashMap::default();
-        let mut s2_prev = '_';
-        for i in set1 {
-            let s2_next = set2.next();
-
-            if s2_next.is_none() && truncate {
-                map.insert(i as usize, i);
-            } else {
-                s2_prev = s2_next.unwrap_or(s2_prev);
-                map.insert(i as usize, s2_prev);
-            }
-        }
-        TranslateOperation {
-            translate_map: map,
-            complement,
-            s2_last: set2.last().unwrap_or(s2_prev),
-        }
-    }
-}
-
-impl SymbolTranslator for TranslateOperation {
-    fn translate(&self, c: char, _prev_c: char) -> Option<char> {
-        if self.complement {
-            Some(if self.translate_map.contains_key(&(c as usize)) {
-                c
-            } else {
-                self.s2_last
-            })
-        } else {
-            Some(*self.translate_map.get(&(c as usize)).unwrap_or(&c))
-        }
-    }
-}
-
-struct TranslateAndSqueezeOperation {
-    translate: TranslateOperation,
-    squeeze: SqueezeOperation,
-}
-
-impl TranslateAndSqueezeOperation {
-    fn new(sets: Vec<String>, truncate: bool, complement: bool) -> TranslateAndSqueezeOperation {
-        let set1 = ExpandSet::new(sets[0].as_ref());
-        let set1_ = ExpandSet::new(sets[0].as_ref());
-        let mut set2 = ExpandSet::new(sets[1].as_ref());
-        let set2_ = ExpandSet::new(sets[1].as_ref());
-        TranslateAndSqueezeOperation {
-            translate: TranslateOperation::new(set1, &mut set2, truncate, complement),
-            squeeze: SqueezeOperation::new(if complement { set1_ } else { set2_ }, complement),
-        }
-    }
-}
-
-impl SymbolTranslator for TranslateAndSqueezeOperation {
-    fn translate(&self, c: char, prev_c: char) -> Option<char> {
-        // `unwrap()` will never panic because `Translate.translate()`
-        // always returns `Some`.
-        self.squeeze
-            .translate(self.translate.translate(c, 0 as char).unwrap(), prev_c)
-    }
-}
-
-fn translate_input<T: SymbolTranslator>(
-    input: &mut dyn BufRead,
-    output: &mut dyn Write,
-    translator: T,
-) {
-    let mut buf = String::with_capacity(BUFFER_LEN + 4);
-    let mut output_buf = String::with_capacity(BUFFER_LEN + 4);
-
-    while let Ok(length) = input.read_line(&mut buf) {
-        let mut prev_c = 0 as char;
-        if length == 0 {
-            break;
-        }
-        {
-            // isolation to make borrow checker happy
-            let filtered = buf.chars().filter_map(|c| {
-                let res = translator.translate(c, prev_c);
-                // Set `prev_c` to the post-translate character. This
-                // allows the squeeze operation to correctly function
-                // after the translate operation.
-                if let Some(rc) = res {
-                    prev_c = rc;
-                }
-                res
-            });
-
-            output_buf.extend(filtered);
-            output.write_all(output_buf.as_bytes()).unwrap();
-        }
-        buf.clear();
-        output_buf.clear();
-    }
-}
-
-fn usage() -> String {
-    format!("{} [OPTION]... SET1 [SET2]", uucore::execution_phrase())
-}
-
 fn get_long_usage() -> String {
-    "Translate, squeeze, and/or delete characters from standard input,
-writing to standard output."
+    "Translate, squeeze, and/or delete characters from standard input, \
+     writing to standard output."
         .to_string()
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
 
-    let usage = usage();
     let after_help = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let delete_flag = matches.is_present(options::DELETE);
-    let complement_flag = matches.is_present(options::COMPLEMENT) || matches.is_present("C");
+    let complement_flag = matches.is_present(options::COMPLEMENT);
     let squeeze_flag = matches.is_present(options::SQUEEZE);
-    let truncate_flag = matches.is_present(options::TRUNCATE);
+    let truncate_set1_flag = matches.is_present(options::TRUNCATE_SET1);
 
     let sets = matches
         .values_of(options::SETS)
-        .map(|v| v.map(ToString::to_string).collect::<Vec<_>>())
+        .map(|v| {
+            v.map(ToString::to_string)
+                .map(|input| convert::reduce_octal_to_char(&input))
+                .collect::<Vec<_>>()
+        })
         .unwrap_or_default();
+    let sets_len = sets.len();
 
     if sets.is_empty() {
-        show_error!(
-            "missing operand\nTry '{} --help' for more information.",
-            uucore::execution_phrase()
-        );
-        return 1;
+        return Err(UUsageError::new(1, "missing operand"));
     }
 
-    if !(delete_flag || squeeze_flag) && sets.len() < 2 {
-        show_error!(
-            "missing operand after {}\nTry '{} --help' for more information.",
-            sets[0].quote(),
-            uucore::execution_phrase()
-        );
-        return 1;
+    if !(delete_flag || squeeze_flag) && sets_len < 2 {
+        return Err(UUsageError::new(
+            1,
+            format!("missing operand after {}", sets[0].quote()),
+        ));
+    }
+
+    if let Some(first) = sets.get(0) {
+        if first.ends_with('\\') {
+            show!(USimpleError::new(
+                0,
+                "warning: an unescaped backslash at end of string is not portable"
+            ));
+        }
     }
 
     let stdin = stdin();
@@ -284,74 +89,93 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     let locked_stdout = stdout.lock();
     let mut buffered_stdout = BufWriter::new(locked_stdout);
 
-    let set1 = ExpandSet::new(sets[0].as_ref());
+    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(),
+        truncate_set1_flag,
+    )?;
+
     if delete_flag {
         if squeeze_flag {
-            let set2 = ExpandSet::new(sets[1].as_ref());
-            let op = DeleteAndSqueezeOperation::new(set1, set2, complement_flag);
-            translate_input(&mut locked_stdin, &mut buffered_stdout, op);
+            let mut delete_buffer = vec![];
+            {
+                let mut delete_writer = BufWriter::new(&mut delete_buffer);
+                let delete_op = DeleteOperation::new(set1, complement_flag);
+                translate_input(&mut locked_stdin, &mut delete_writer, delete_op);
+            }
+            {
+                let mut squeeze_reader = BufReader::new(delete_buffer.as_bytes());
+                let op = SqueezeOperation::new(set2, complement_flag);
+                translate_input(&mut squeeze_reader, &mut buffered_stdout, op);
+            }
         } else {
             let op = DeleteOperation::new(set1, complement_flag);
             translate_input(&mut locked_stdin, &mut buffered_stdout, op);
         }
     } else if squeeze_flag {
-        if sets.len() < 2 {
+        if sets_len < 2 {
             let op = SqueezeOperation::new(set1, complement_flag);
             translate_input(&mut locked_stdin, &mut buffered_stdout, op);
         } else {
-            let op = TranslateAndSqueezeOperation::new(sets, truncate_flag, complement_flag);
-            translate_input(&mut locked_stdin, &mut buffered_stdout, op);
+            let mut translate_buffer = vec![];
+            {
+                let mut writer = BufWriter::new(&mut translate_buffer);
+                let op = TranslateOperation::new(set1, set2.clone(), complement_flag)?;
+                translate_input(&mut locked_stdin, &mut writer, op);
+            }
+            {
+                let mut reader = BufReader::new(translate_buffer.as_bytes());
+                let squeeze_op = SqueezeOperation::new(set2, false);
+                translate_input(&mut reader, &mut buffered_stdout, squeeze_op);
+            }
         }
     } else {
-        let mut set2 = ExpandSet::new(sets[1].as_ref());
-        let op = TranslateOperation::new(set1, &mut set2, truncate_flag, complement_flag);
+        let op = TranslateOperation::new(set1, set2, complement_flag)?;
         translate_input(&mut locked_stdin, &mut buffered_stdout, op);
     }
-
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::COMPLEMENT)
-                // .visible_short_alias('C')  // TODO: requires clap "3.0.0-beta.2"
-                .short("c")
+            Arg::new(options::COMPLEMENT)
+                .visible_short_alias('C')
+                .short('c')
                 .long(options::COMPLEMENT)
                 .help("use the complement of SET1"),
         )
         .arg(
-            Arg::with_name("C") // work around for `Arg::visible_short_alias`
-                .short("C")
-                .help("same as -c"),
-        )
-        .arg(
-            Arg::with_name(options::DELETE)
-                .short("d")
+            Arg::new(options::DELETE)
+                .short('d')
                 .long(options::DELETE)
                 .help("delete characters in SET1, do not translate"),
         )
         .arg(
-            Arg::with_name(options::SQUEEZE)
+            Arg::new(options::SQUEEZE)
                 .long(options::SQUEEZE)
-                .short("s")
+                .short('s')
                 .help(
-                    "replace each sequence  of  a  repeated  character  that  is
-  listed  in the last specified SET, with a single occurrence
-  of that character",
+                    "replace each sequence of a repeated character that is \
+                     listed in the last specified SET, with a single occurrence \
+                     of that character",
                 ),
         )
         .arg(
-            Arg::with_name(options::TRUNCATE)
-                .long(options::TRUNCATE)
-                .short("t")
+            Arg::new(options::TRUNCATE_SET1)
+                .long(options::TRUNCATE_SET1)
+                .short('t')
                 .help("first truncate SET1 to length of SET2"),
         )
         .arg(
-            Arg::with_name(options::SETS)
-                .multiple(true)
+            Arg::new(options::SETS)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .min_values(1)
                 .max_values(2),
diff --git a/src/uu/tr/src/unicode_table.rs b/src/uu/tr/src/unicode_table.rs
new file mode 100644
index 000000000..43d9fd6f4
--- /dev/null
+++ b/src/uu/tr/src/unicode_table.rs
@@ -0,0 +1,15 @@
+//  * 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 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];
diff --git a/src/uu/true/Cargo.toml b/src/uu/true/Cargo.toml
index 369bbb51f..bd3bda2ba 100644
--- a/src/uu/true/Cargo.toml
+++ b/src/uu/true/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_true"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "true ~ (uutils) do nothing and succeed"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/true"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/true"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/true.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "true"
diff --git a/src/uu/true/LICENSE b/src/uu/true/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/true/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/true/src/main.rs b/src/uu/true/src/main.rs
index b30f4d4cb..700bece65 100644
--- a/src/uu/true/src/main.rs
+++ b/src/uu/true/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_true);
+uucore::bin!(uu_true);
diff --git a/src/uu/true/src/true.rs b/src/uu/true/src/true.rs
index b5fbf7c9d..57c3d2af5 100644
--- a/src/uu/true/src/true.rs
+++ b/src/uu/true/src/true.rs
@@ -4,16 +4,60 @@
 //  *
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
+use clap::{Arg, Command};
+use std::io::Write;
+use uucore::error::{set_exit_code, UResult};
 
-use clap::App;
-use uucore::error::UResult;
+static ABOUT: &str = "\
+Returns true, a successful exit status.
 
-#[uucore_procs::gen_uumain]
+Immediately returns with the exit status `0`, except when invoked with one of the recognized
+options. In those cases it will try to write the help or version text. Any IO error during this
+operation causes the program to return `1` instead.
+";
+
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    uu_app().get_matches_from(args);
+    let mut command = uu_app();
+
+    if let Ok(matches) = command.try_get_matches_from_mut(args) {
+        let error = if matches.index_of("help").is_some() {
+            command.print_long_help()
+        } else if matches.index_of("version").is_some() {
+            writeln!(std::io::stdout(), "{}", command.render_version())
+        } else {
+            Ok(())
+        };
+
+        if let Err(print_fail) = error {
+            // Try to display this error.
+            let _ = writeln!(std::io::stderr(), "{}: {}", uucore::util_name(), print_fail);
+            // Mirror GNU options. When failing to print warnings or version flags, then we exit
+            // with FAIL. This avoids allocation some error information which may result in yet
+            // other types of failure.
+            set_exit_code(1);
+        }
+    }
+
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
+        .version(clap::crate_version!())
+        .about(ABOUT)
+        // We provide our own help and version options, to ensure maximum compatibility with GNU.
+        .disable_help_flag(true)
+        .disable_version_flag(true)
+        .arg(
+            Arg::new("help")
+                .long("help")
+                .help("Print help information")
+                .exclusive(true),
+        )
+        .arg(
+            Arg::new("version")
+                .long("version")
+                .help("Print version information"),
+        )
 }
diff --git a/src/uu/truncate/Cargo.toml b/src/uu/truncate/Cargo.toml
index 811aa6ef6..348b1498f 100644
--- a/src/uu/truncate/Cargo.toml
+++ b/src/uu/truncate/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_truncate"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "truncate ~ (uutils) truncate (or extend) FILE to SIZE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/truncate"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/truncate"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/truncate.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "truncate"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/truncate/LICENSE b/src/uu/truncate/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/truncate/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/truncate/src/main.rs b/src/uu/truncate/src/main.rs
index 46e65faea..6900db57d 100644
--- a/src/uu/truncate/src/main.rs
+++ b/src/uu/truncate/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_truncate);
+uucore::bin!(uu_truncate);
diff --git a/src/uu/truncate/src/truncate.rs b/src/uu/truncate/src/truncate.rs
index 6fb1f06f6..6c9d8197b 100644
--- a/src/uu/truncate/src/truncate.rs
+++ b/src/uu/truncate/src/truncate.rs
@@ -6,27 +6,26 @@
 //  * file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) RFILE refsize rfilename fsize tsize
-
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
-use std::convert::TryFrom;
+use clap::{crate_version, Arg, Command};
 use std::fs::{metadata, OpenOptions};
 use std::io::ErrorKind;
+#[cfg(unix)]
+use std::os::unix::fs::FileTypeExt;
 use std::path::Path;
 use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::format_usage;
 use uucore::parse_size::{parse_size, ParseSizeError};
 
 #[derive(Debug, Eq, PartialEq)]
 enum TruncateMode {
-    Absolute(usize),
-    Extend(usize),
-    Reduce(usize),
-    AtMost(usize),
-    AtLeast(usize),
-    RoundDown(usize),
-    RoundUp(usize),
+    Absolute(u64),
+    Extend(u64),
+    Reduce(u64),
+    AtMost(u64),
+    AtLeast(u64),
+    RoundDown(u64),
+    RoundUp(u64),
 }
 
 impl TruncateMode {
@@ -34,18 +33,38 @@ impl TruncateMode {
     ///
     /// `fsize` is the size of the reference file, in bytes.
     ///
+    /// If the mode is [`TruncateMode::Reduce`] and the value to
+    /// reduce by is greater than `fsize`, then this function returns
+    /// 0 (since it cannot return a negative number).
+    ///
     /// # Examples
     ///
+    /// Extending a file of 10 bytes by 5 bytes:
+    ///
     /// ```rust,ignore
     /// let mode = TruncateMode::Extend(5);
     /// let fsize = 10;
     /// assert_eq!(mode.to_size(fsize), 15);
     /// ```
-    fn to_size(&self, fsize: usize) -> usize {
+    ///
+    /// Reducing a file by more than its size results in 0:
+    ///
+    /// ```rust,ignore
+    /// let mode = TruncateMode::Reduce(5);
+    /// let fsize = 3;
+    /// assert_eq!(mode.to_size(fsize), 0);
+    /// ```
+    fn to_size(&self, fsize: u64) -> u64 {
         match self {
             TruncateMode::Absolute(size) => *size,
             TruncateMode::Extend(size) => fsize + size,
-            TruncateMode::Reduce(size) => fsize - size,
+            TruncateMode::Reduce(size) => {
+                if *size > fsize {
+                    0
+                } else {
+                    fsize - size
+                }
+            }
             TruncateMode::AtMost(size) => fsize.min(*size),
             TruncateMode::AtLeast(size) => fsize.max(*size),
             TruncateMode::RoundDown(size) => fsize - fsize % size,
@@ -55,6 +74,7 @@ impl TruncateMode {
 }
 
 static ABOUT: &str = "Shrink or extend the size of each file to the specified size.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
 pub mod options {
     pub static IO_BLOCKS: &str = "io-blocks";
@@ -64,10 +84,6 @@ pub mod options {
     pub static ARG_FILES: &str = "files";
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]... [FILE]...", uucore::execution_phrase())
-}
-
 fn get_long_usage() -> String {
     String::from(
         "
@@ -90,14 +106,20 @@ fn get_long_usage() -> String {
     )
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let long_usage = get_long_usage();
 
     let matches = uu_app()
-        .usage(&usage[..])
         .after_help(&long_usage[..])
-        .get_matches_from(args);
+        .try_get_matches_from(args)
+        .map_err(|e| {
+            e.print().expect("Error writing clap::Error");
+            match e.kind() {
+                clap::ErrorKind::DisplayHelp | clap::ErrorKind::DisplayVersion => 0,
+                _ => 1,
+            }
+        })?;
 
     let files: Vec<String> = matches
         .values_of(options::ARG_FILES)
@@ -105,69 +127,53 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         .unwrap_or_default();
 
     if files.is_empty() {
-        show_error!("Missing an argument");
-        return 1;
+        return Err(UUsageError::new(1, "missing file operand"));
     } else {
         let io_blocks = matches.is_present(options::IO_BLOCKS);
         let no_create = matches.is_present(options::NO_CREATE);
         let reference = matches.value_of(options::REFERENCE).map(String::from);
         let size = matches.value_of(options::SIZE).map(String::from);
-        if let Err(e) = truncate(no_create, io_blocks, reference, size, files) {
-            match e.kind() {
-                ErrorKind::NotFound => {
-                    // TODO Improve error-handling so that the error
-                    // returned by `truncate()` provides the necessary
-                    // parameter for formatting the error message.
-                    let reference = matches.value_of(options::REFERENCE).map(String::from);
-                    crash!(
-                        1,
-                        "cannot stat {}: No such file or directory",
-                        reference.as_deref().unwrap_or("").quote()
-                    ); // TODO: fix '--no-create' see test_reference and test_truncate_bytes_size
-                }
-                _ => crash!(1, "{}", e.to_string()),
-            }
-        }
+        truncate(no_create, io_blocks, reference, size, &files)
     }
-
-    0
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::IO_BLOCKS)
-            .short("o")
+            Arg::new(options::IO_BLOCKS)
+            .short('o')
             .long(options::IO_BLOCKS)
             .help("treat SIZE as the number of I/O blocks of the file rather than bytes (NOT IMPLEMENTED)")
         )
         .arg(
-            Arg::with_name(options::NO_CREATE)
-            .short("c")
+            Arg::new(options::NO_CREATE)
+            .short('c')
             .long(options::NO_CREATE)
             .help("do not create files that do not exist")
         )
         .arg(
-            Arg::with_name(options::REFERENCE)
-            .short("r")
+            Arg::new(options::REFERENCE)
+            .short('r')
             .long(options::REFERENCE)
-            .required_unless(options::SIZE)
+            .required_unless_present(options::SIZE)
             .help("base the size of each file on the size of RFILE")
             .value_name("RFILE")
         )
         .arg(
-            Arg::with_name(options::SIZE)
-            .short("s")
+            Arg::new(options::SIZE)
+            .short('s')
             .long(options::SIZE)
-            .required_unless(options::REFERENCE)
+            .required_unless_present(options::REFERENCE)
             .help("set or adjust the size of each file according to SIZE, which is in bytes unless --io-blocks is specified")
             .value_name("SIZE")
         )
-        .arg(Arg::with_name(options::ARG_FILES)
+        .arg(Arg::new(options::ARG_FILES)
              .value_name("FILE")
-             .multiple(true)
+             .multiple_occurrences(true)
              .takes_value(true)
              .required(true)
              .min_values(1))
@@ -185,10 +191,10 @@ pub fn uu_app() -> App<'static, 'static> {
 ///
 /// If the file could not be opened, or there was a problem setting the
 /// size of the file.
-fn file_truncate(filename: &str, create: bool, size: usize) -> std::io::Result<()> {
+fn file_truncate(filename: &str, create: bool, size: u64) -> std::io::Result<()> {
     let path = Path::new(filename);
     let f = OpenOptions::new().write(true).create(create).open(path)?;
-    f.set_len(u64::try_from(size).unwrap())
+    f.set_len(size)
 }
 
 /// Truncate files to a size relative to a given file.
@@ -204,27 +210,55 @@ fn file_truncate(filename: &str, create: bool, size: usize) -> std::io::Result<(
 ///
 /// # Errors
 ///
-/// If the any file could not be opened, or there was a problem setting
+/// If any file could not be opened, or there was a problem setting
 /// the size of at least one file.
+///
+/// If at least one file is a named pipe (also known as a fifo).
 fn truncate_reference_and_size(
     rfilename: &str,
     size_string: &str,
-    filenames: Vec<String>,
+    filenames: &[String],
     create: bool,
-) -> std::io::Result<()> {
+) -> UResult<()> {
     let mode = match parse_mode_and_size(size_string) {
-        Ok(m) => match m {
-            TruncateMode::Absolute(_) => {
-                crash!(1, "you must specify a relative '--size' with '--reference'")
-            }
-            _ => m,
-        },
-        Err(e) => crash!(1, "Invalid number: {}", e.to_string()),
+        Err(e) => return Err(USimpleError::new(1, format!("Invalid number: {}", e))),
+        Ok(TruncateMode::Absolute(_)) => {
+            return Err(USimpleError::new(
+                1,
+                String::from("you must specify a relative '--size' with '--reference'"),
+            ))
+        }
+        Ok(m) => m,
     };
-    let fsize = usize::try_from(metadata(rfilename)?.len()).unwrap();
+    if let TruncateMode::RoundDown(0) | TruncateMode::RoundUp(0) = mode {
+        return Err(USimpleError::new(1, "division by zero"));
+    }
+    let metadata = metadata(rfilename).map_err(|e| match e.kind() {
+        ErrorKind::NotFound => USimpleError::new(
+            1,
+            format!(
+                "cannot stat {}: No such file or directory",
+                rfilename.quote()
+            ),
+        ),
+        _ => e.map_err_context(String::new),
+    })?;
+    let fsize = metadata.len();
     let tsize = mode.to_size(fsize);
-    for filename in &filenames {
-        file_truncate(filename, create, tsize)?;
+    for filename in filenames {
+        #[cfg(unix)]
+        if std::fs::metadata(filename)?.file_type().is_fifo() {
+            return Err(USimpleError::new(
+                1,
+                format!(
+                    "cannot open {} for writing: No such device or address",
+                    filename.quote()
+                ),
+            ));
+        }
+
+        file_truncate(filename, create, tsize)
+            .map_err_context(|| format!("cannot open {} for writing", filename.quote()))?;
     }
     Ok(())
 }
@@ -238,16 +272,39 @@ fn truncate_reference_and_size(
 ///
 /// # Errors
 ///
-/// If the any file could not be opened, or there was a problem setting
+/// If any file could not be opened, or there was a problem setting
 /// the size of at least one file.
+///
+/// If at least one file is a named pipe (also known as a fifo).
 fn truncate_reference_file_only(
     rfilename: &str,
-    filenames: Vec<String>,
+    filenames: &[String],
     create: bool,
-) -> std::io::Result<()> {
-    let tsize = usize::try_from(metadata(rfilename)?.len()).unwrap();
-    for filename in &filenames {
-        file_truncate(filename, create, tsize)?;
+) -> UResult<()> {
+    let metadata = metadata(rfilename).map_err(|e| match e.kind() {
+        ErrorKind::NotFound => USimpleError::new(
+            1,
+            format!(
+                "cannot stat {}: No such file or directory",
+                rfilename.quote()
+            ),
+        ),
+        _ => e.map_err_context(String::new),
+    })?;
+    let tsize = metadata.len();
+    for filename in filenames {
+        #[cfg(unix)]
+        if std::fs::metadata(filename)?.file_type().is_fifo() {
+            return Err(USimpleError::new(
+                1,
+                format!(
+                    "cannot open {} for writing: No such device or address",
+                    filename.quote()
+                ),
+            ));
+        }
+        file_truncate(filename, create, tsize)
+            .map_err_context(|| format!("cannot open {} for writing", filename.quote()))?;
     }
     Ok(())
 }
@@ -265,21 +322,43 @@ fn truncate_reference_file_only(
 ///
 /// # Errors
 ///
-/// If the any file could not be opened, or there was a problem setting
+/// If any file could not be opened, or there was a problem setting
 /// the size of at least one file.
-fn truncate_size_only(
-    size_string: &str,
-    filenames: Vec<String>,
-    create: bool,
-) -> std::io::Result<()> {
-    let mode = match parse_mode_and_size(size_string) {
-        Ok(m) => m,
-        Err(e) => crash!(1, "Invalid number: {}", e.to_string()),
-    };
-    for filename in &filenames {
-        let fsize = usize::try_from(metadata(filename)?.len()).unwrap();
+///
+/// If at least one file is a named pipe (also known as a fifo).
+fn truncate_size_only(size_string: &str, filenames: &[String], create: bool) -> UResult<()> {
+    let mode = parse_mode_and_size(size_string)
+        .map_err(|e| USimpleError::new(1, format!("Invalid number: {}", e)))?;
+    if let TruncateMode::RoundDown(0) | TruncateMode::RoundUp(0) = mode {
+        return Err(USimpleError::new(1, "division by zero"));
+    }
+    for filename in filenames {
+        let fsize = match metadata(filename) {
+            Ok(m) => {
+                #[cfg(unix)]
+                if m.file_type().is_fifo() {
+                    return Err(USimpleError::new(
+                        1,
+                        format!(
+                            "cannot open {} for writing: No such device or address",
+                            filename.quote()
+                        ),
+                    ));
+                }
+                m.len()
+            }
+            Err(_) => 0,
+        };
         let tsize = mode.to_size(fsize);
-        file_truncate(filename, create, tsize)?;
+        match file_truncate(filename, create, tsize) {
+            Ok(_) => continue,
+            Err(e) if e.kind() == ErrorKind::NotFound && !create => continue,
+            Err(e) => {
+                return Err(
+                    e.map_err_context(|| format!("cannot open {} for writing", filename.quote()))
+                )
+            }
+        }
     }
     Ok(())
 }
@@ -289,8 +368,8 @@ fn truncate(
     _: bool,
     reference: Option<String>,
     size: Option<String>,
-    filenames: Vec<String>,
-) -> std::io::Result<()> {
+    filenames: &[String],
+) -> UResult<()> {
     let create = !no_create;
     // There are four possibilities
     // - reference file given and size given,
@@ -303,7 +382,7 @@ fn truncate(
         }
         (Some(rfilename), None) => truncate_reference_file_only(&rfilename, filenames, create),
         (None, Some(size_string)) => truncate_size_only(&size_string, filenames, create),
-        (None, None) => crash!(1, "you must specify either --reference or --size"), // this case cannot happen anymore because it's handled by clap
+        (None, None) => unreachable!(), // this case cannot happen anymore because it's handled by clap
     }
 }
 
@@ -369,4 +448,11 @@ mod tests {
         assert_eq!(parse_mode_and_size("/10"), Ok(TruncateMode::RoundDown(10)));
         assert_eq!(parse_mode_and_size("%10"), Ok(TruncateMode::RoundUp(10)));
     }
+
+    #[test]
+    fn test_to_size() {
+        assert_eq!(TruncateMode::Extend(5).to_size(10), 15);
+        assert_eq!(TruncateMode::Reduce(5).to_size(10), 5);
+        assert_eq!(TruncateMode::Reduce(5).to_size(3), 0);
+    }
 }
diff --git a/src/uu/tsort/Cargo.toml b/src/uu/tsort/Cargo.toml
index bcc2dd757..61fe36903 100644
--- a/src/uu/tsort/Cargo.toml
+++ b/src/uu/tsort/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_tsort"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tsort ~ (uutils) topologically sort input (partially ordered) pairs"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/tsort"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tsort"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,14 +15,9 @@ edition = "2018"
 path = "src/tsort.rs"
 
 [dependencies]
-clap= "2.33"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "tsort"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/tsort/LICENSE b/src/uu/tsort/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/tsort/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/tsort/src/main.rs b/src/uu/tsort/src/main.rs
index 0694678d4..480d14ffd 100644
--- a/src/uu/tsort/src/main.rs
+++ b/src/uu/tsort/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_tsort);
+uucore::bin!(uu_tsort);
diff --git a/src/uu/tsort/src/tsort.rs b/src/uu/tsort/src/tsort.rs
index 11798db13..aecd492fe 100644
--- a/src/uu/tsort/src/tsort.rs
+++ b/src/uu/tsort/src/tsort.rs
@@ -5,17 +5,14 @@
 //  *
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
-
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::{stdin, BufRead, BufReader, Read};
 use std::path::Path;
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static SUMMARY: &str = "Topological sort the strings in FILE.
 Strings are defined as any sequence of tokens separated by whitespace (tab, space, or newline).
@@ -26,7 +23,8 @@ mod options {
     pub const FILE: &str = "file";
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
@@ -43,13 +41,7 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         stdin_buf = stdin();
         &mut stdin_buf as &mut dyn Read
     } else {
-        file_buf = match File::open(Path::new(&input)) {
-            Ok(a) => a,
-            _ => {
-                show_error!("{}: No such file or directory", input.maybe_quote());
-                return 1;
-            }
-        };
+        file_buf = File::open(Path::new(&input)).map_err_context(|| input.to_string())?;
         &mut file_buf as &mut dyn Read
     });
 
@@ -69,11 +61,15 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
                 for ab in tokens.chunks(2) {
                     match ab.len() {
                         2 => g.add_edge(&ab[0], &ab[1]),
-                        _ => crash!(
-                            1,
-                            "{}: input contains an odd number of tokens",
-                            input.maybe_quote()
-                        ),
+                        _ => {
+                            return Err(USimpleError::new(
+                                1,
+                                format!(
+                                    "{}: input contains an odd number of tokens",
+                                    input.maybe_quote()
+                                ),
+                            ))
+                        }
                     }
                 }
             }
@@ -84,30 +80,31 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     g.run_tsort();
 
     if !g.is_acyclic() {
-        crash!(1, "{}, input contains a loop:", input);
+        return Err(USimpleError::new(
+            1,
+            format!("{}, input contains a loop:", input),
+        ));
     }
 
     for x in &g.result {
         println!("{}", x);
     }
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
-        .arg(
-            Arg::with_name(options::FILE)
-                .default_value("-")
-                .hidden(true),
-        )
+        .infer_long_args(true)
+        .arg(Arg::new(options::FILE).default_value("-").hide(true))
 }
 
 // We use String as a representation of node here
 // but using integer may improve performance.
+#[derive(Default)]
 struct Graph {
     in_edges: HashMap<String, HashSet<String>>,
     out_edges: HashMap<String, Vec<String>>,
@@ -115,12 +112,8 @@ struct Graph {
 }
 
 impl Graph {
-    fn new() -> Graph {
-        Graph {
-            in_edges: HashMap::new(),
-            out_edges: HashMap::new(),
-            result: vec![],
-        }
+    fn new() -> Self {
+        Self::default()
     }
 
     fn has_node(&self, n: &str) -> bool {
diff --git a/src/uu/tty/Cargo.toml b/src/uu/tty/Cargo.toml
index 5b2e18cd2..d99a8e762 100644
--- a/src/uu/tty/Cargo.toml
+++ b/src/uu/tty/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_tty"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "tty ~ (uutils) display the name of the terminal connected to standard input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/tty"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tty"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,11 +15,10 @@ edition = "2018"
 path = "src/tty.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-libc = "0.2.42"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+libc = "0.2.121"
 atty = "0.2"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["fs"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["fs"] }
 
 [[bin]]
 name = "tty"
diff --git a/src/uu/tty/LICENSE b/src/uu/tty/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/tty/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/tty/src/main.rs b/src/uu/tty/src/main.rs
index 01a01e5ca..4b708cd95 100644
--- a/src/uu/tty/src/main.rs
+++ b/src/uu/tty/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_tty);
+uucore::bin!(uu_tty);
diff --git a/src/uu/tty/src/tty.rs b/src/uu/tty/src/tty.rs
index 94e2e6b24..4ae5ad007 100644
--- a/src/uu/tty/src/tty.rs
+++ b/src/uu/tty/src/tty.rs
@@ -9,36 +9,26 @@
 
 // spell-checker:ignore (ToDO) ttyname filedesc
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::ffi::CStr;
 use std::io::Write;
-use uucore::InvalidEncodingHandling;
+use uucore::error::UResult;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static ABOUT: &str = "Print the file name of the terminal connected to standard input.";
+const USAGE: &str = "{} [OPTION]...";
 
 mod options {
     pub const SILENT: &str = "silent";
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]...", uucore::execution_phrase())
-}
-
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::ConvertLossy)
         .accept_any();
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from_safe(args);
-
-    let matches = match matches {
-        Ok(m) => m,
-        Err(e) => {
-            eprint!("{}", e);
-            return 2;
-        }
-    };
+    let matches = uu_app().get_matches_from(args);
 
     let silent = matches.is_present(options::SILENT);
 
@@ -68,21 +58,23 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     }
 
     if atty::is(atty::Stream::Stdin) {
-        libc::EXIT_SUCCESS
+        Ok(())
     } else {
-        libc::EXIT_FAILURE
+        Err(libc::EXIT_FAILURE.into())
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::SILENT)
+            Arg::new(options::SILENT)
                 .long(options::SILENT)
                 .visible_alias("quiet")
-                .short("s")
+                .short('s')
                 .help("print nothing, only return an exit status")
                 .required(false),
         )
diff --git a/src/uu/uname/Cargo.toml b/src/uu/uname/Cargo.toml
index 90a103075..8717d210f 100644
--- a/src/uu/uname/Cargo.toml
+++ b/src/uu/uname/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_uname"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uname ~ (uutils) display system information"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/uname"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/uname"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/uname.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-platform-info = "0.1"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+platform-info = "0.2"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "uname"
diff --git a/src/uu/uname/LICENSE b/src/uu/uname/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/uname/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/uname/src/main.rs b/src/uu/uname/src/main.rs
index 5252f4716..98640b395 100644
--- a/src/uu/uname/src/main.rs
+++ b/src/uu/uname/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_uname);
+uucore::bin!(uu_uname);
diff --git a/src/uu/uname/src/uname.rs b/src/uu/uname/src/uname.rs
index 2c396081e..bff033047 100644
--- a/src/uu/uname/src/uname.rs
+++ b/src/uu/uname/src/uname.rs
@@ -10,13 +10,15 @@
 
 // spell-checker:ignore (ToDO) nodename kernelname kernelrelease kernelversion sysname hwplatform mnrsv
 
-#[macro_use]
-extern crate uucore;
-
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use platform_info::*;
+use uucore::{
+    error::{FromIo, UResult},
+    format_usage,
+};
 
 const ABOUT: &str = "Print certain system information.  With no OPTION, same as -s.";
+const USAGE: &str = "{} [OPTION]...";
 
 pub mod options {
     pub static ALL: &str = "all";
@@ -49,11 +51,12 @@ const HOST_OS: &str = "Fuchsia";
 #[cfg(target_os = "redox")]
 const HOST_OS: &str = "Redox";
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = format!("{} [OPTION]...", uucore::execution_phrase());
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
 
-    let uname = crash_if_err!(1, PlatformInfo::new());
+    let uname =
+        PlatformInfo::new().map_err_context(|| "failed to create PlatformInfo".to_string())?;
     let mut output = String::new();
 
     let all = matches.is_present(options::ALL);
@@ -115,49 +118,51 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
     }
     println!("{}", output.trim_end());
 
-    0
+    Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .arg(Arg::with_name(options::ALL)
-            .short("a")
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .arg(Arg::new(options::ALL)
+            .short('a')
             .long(options::ALL)
             .help("Behave as though all of the options -mnrsv were specified."))
-        .arg(Arg::with_name(options::KERNELNAME)
-            .short("s")
+        .arg(Arg::new(options::KERNELNAME)
+            .short('s')
             .long(options::KERNELNAME)
             .alias("sysname") // Obsolescent option in GNU uname
             .help("print the kernel name."))
-        .arg(Arg::with_name(options::NODENAME)
-            .short("n")
+        .arg(Arg::new(options::NODENAME)
+            .short('n')
             .long(options::NODENAME)
             .help("print the nodename (the nodename may be a name that the system is known by to a communications network)."))
-        .arg(Arg::with_name(options::KERNELRELEASE)
-            .short("r")
+        .arg(Arg::new(options::KERNELRELEASE)
+            .short('r')
             .long(options::KERNELRELEASE)
             .alias("release") // Obsolescent option in GNU uname
             .help("print the operating system release."))
-        .arg(Arg::with_name(options::KERNELVERSION)
-            .short("v")
+        .arg(Arg::new(options::KERNELVERSION)
+            .short('v')
             .long(options::KERNELVERSION)
             .help("print the operating system version."))
-        .arg(Arg::with_name(options::HWPLATFORM)
-            .short("i")
+        .arg(Arg::new(options::HWPLATFORM)
+            .short('i')
             .long(options::HWPLATFORM)
             .help("print the hardware platform (non-portable)"))
-        .arg(Arg::with_name(options::MACHINE)
-            .short("m")
+        .arg(Arg::new(options::MACHINE)
+            .short('m')
             .long(options::MACHINE)
             .help("print the machine hardware name."))
-        .arg(Arg::with_name(options::PROCESSOR)
-            .short("p")
+        .arg(Arg::new(options::PROCESSOR)
+            .short('p')
             .long(options::PROCESSOR)
             .help("print the processor type (non-portable)"))
-        .arg(Arg::with_name(options::OS)
-            .short("o")
+        .arg(Arg::new(options::OS)
+            .short('o')
             .long(options::OS)
             .help("print the operating system name."))
 }
diff --git a/src/uu/unexpand/Cargo.toml b/src/uu/unexpand/Cargo.toml
index 026a12872..6a9c81864 100644
--- a/src/uu/unexpand/Cargo.toml
+++ b/src/uu/unexpand/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_unexpand"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "unexpand ~ (uutils) convert input spaces to tabs"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/unexpand"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/unexpand"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,10 @@ edition = "2018"
 path = "src/unexpand.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
 unicode-width = "0.1.5"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "unexpand"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/unexpand/LICENSE b/src/uu/unexpand/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/unexpand/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/unexpand/src/main.rs b/src/uu/unexpand/src/main.rs
index 2e7b1d967..d7c90ba7e 100644
--- a/src/uu/unexpand/src/main.rs
+++ b/src/uu/unexpand/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_unexpand);
+uucore::bin!(uu_unexpand);
diff --git a/src/uu/unexpand/src/unexpand.rs b/src/uu/unexpand/src/unexpand.rs
index 95383b89d..910ff91d3 100644
--- a/src/uu/unexpand/src/unexpand.rs
+++ b/src/uu/unexpand/src/unexpand.rs
@@ -11,22 +11,23 @@
 
 #[macro_use]
 extern crate uucore;
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::fs::File;
 use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Stdout, Write};
 use std::str::from_utf8;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
-use uucore::InvalidEncodingHandling;
+use uucore::error::{FromIo, UResult};
+use uucore::{format_usage, InvalidEncodingHandling};
 
 static NAME: &str = "unexpand";
-static USAGE: &str = "unexpand [OPTION]... [FILE]...";
-static SUMMARY: &str = "Convert blanks in each FILE to tabs, writing to standard output.\n
-                 With no FILE, or when FILE is -, read standard input.";
+static USAGE: &str = "{} [OPTION]... [FILE]...";
+static SUMMARY: &str = "Convert blanks in each FILE to tabs, writing to standard output.\n\
+                        With no FILE, or when FILE is -, read standard input.";
 
 const DEFAULT_TABSTOP: usize = 8;
 
-fn tabstops_parse(s: String) -> Vec<usize> {
+fn tabstops_parse(s: &str) -> Vec<usize> {
     let words = s.split(',');
 
     let nums = words
@@ -66,10 +67,10 @@ struct Options {
 }
 
 impl Options {
-    fn new(matches: clap::ArgMatches) -> Options {
+    fn new(matches: &clap::ArgMatches) -> Self {
         let tabstops = match matches.value_of(options::TABS) {
             None => vec![DEFAULT_TABSTOP],
-            Some(s) => tabstops_parse(s.to_string()),
+            Some(s) => tabstops_parse(s),
         };
 
         let aflag = (matches.is_present(options::ALL) || matches.is_present(options::TABS))
@@ -81,7 +82,7 @@ impl Options {
             None => vec!["-".to_owned()],
         };
 
-        Options {
+        Self {
             files,
             tabstops,
             aflag,
@@ -90,54 +91,54 @@ impl Options {
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
     let matches = uu_app().get_matches_from(args);
 
-    unexpand(Options::new(matches));
-
-    0
+    unexpand(&Options::new(&matches)).map_err_context(String::new)
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .name(NAME)
         .version(crate_version!())
-        .usage(USAGE)
+        .override_usage(format_usage(USAGE))
         .about(SUMMARY)
-        .arg(Arg::with_name(options::FILE).hidden(true).multiple(true))
+        .infer_long_args(true)
+        .arg(Arg::new(options::FILE).hide(true).multiple_occurrences(true))
         .arg(
-            Arg::with_name(options::ALL)
-                .short("a")
+            Arg::new(options::ALL)
+                .short('a')
                 .long(options::ALL)
                 .help("convert all blanks, instead of just initial blanks")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::FIRST_ONLY)
+            Arg::new(options::FIRST_ONLY)
                 .long(options::FIRST_ONLY)
                 .help("convert only leading sequences of blanks (overrides -a)")
                 .takes_value(false),
         )
         .arg(
-            Arg::with_name(options::TABS)
-                .short("t")
+            Arg::new(options::TABS)
+                .short('t')
                 .long(options::TABS)
                 .long_help("use comma separated LIST of tab positions or have tabs N characters apart instead of 8 (enables -a)")
                 .takes_value(true)
         )
         .arg(
-            Arg::with_name(options::NO_UTF8)
-                .short("U")
+            Arg::new(options::NO_UTF8)
+                .short('U')
                 .long(options::NO_UTF8)
                 .takes_value(false)
                 .help("interpret input file as 8-bit ASCII rather than UTF-8"))
 }
 
-fn open(path: String) -> BufReader<Box<dyn Read + 'static>> {
+fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
     let file_buf;
     if path == "-" {
         BufReader::new(Box::new(stdin()) as Box<dyn Read>)
@@ -242,13 +243,13 @@ fn next_char_info(uflag: bool, buf: &[u8], byte: usize) -> (CharType, usize, usi
     (ctype, cwidth, nbytes)
 }
 
-fn unexpand(options: Options) {
+fn unexpand(options: &Options) -> std::io::Result<()> {
     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.into_iter() {
+    for file in &options.files {
         let mut fh = open(file);
 
         while match fh.read_until(b'\n', &mut buf) {
@@ -273,7 +274,7 @@ fn unexpand(options: Options) {
                         init,
                         true,
                     );
-                    crash_if_err!(1, output.write_all(&buf[byte..]));
+                    output.write_all(&buf[byte..])?;
                     scol = col;
                     break;
                 }
@@ -293,7 +294,7 @@ fn unexpand(options: Options) {
                         };
 
                         if !tabs_buffered {
-                            crash_if_err!(1, output.write_all(&buf[byte..byte + nbytes]));
+                            output.write_all(&buf[byte..byte + nbytes])?;
                             scol = col; // now printed up to this column
                         }
                     }
@@ -318,7 +319,7 @@ fn unexpand(options: Options) {
                         } else {
                             0
                         };
-                        crash_if_err!(1, output.write_all(&buf[byte..byte + nbytes]));
+                        output.write_all(&buf[byte..byte + nbytes])?;
                         scol = col; // we've now printed up to this column
                     }
                 }
@@ -337,9 +338,9 @@ fn unexpand(options: Options) {
                 init,
                 true,
             );
-            crash_if_err!(1, output.flush());
+            output.flush()?;
             buf.truncate(0); // clear out the buffer
         }
     }
-    crash_if_err!(1, output.flush())
+    output.flush()
 }
diff --git a/src/uu/uniq/Cargo.toml b/src/uu/uniq/Cargo.toml
index a6fcebc92..2d72e6177 100644
--- a/src/uu/uniq/Cargo.toml
+++ b/src/uu/uniq/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_uniq"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uniq ~ (uutils) filter identical adjacent lines from input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/uniq"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/uniq"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,16 +15,11 @@ edition = "2018"
 path = "src/uniq.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-strum = "0.21"
-strum_macros = "0.21"
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+strum = "0.24.0"
+strum_macros = "0.23.1"
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "uniq"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/uniq/LICENSE b/src/uu/uniq/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/uniq/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/uniq/src/main.rs b/src/uu/uniq/src/main.rs
index 361c39f14..b6e6251cd 100644
--- a/src/uu/uniq/src/main.rs
+++ b/src/uu/uniq/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_uniq);
+uucore::bin!(uu_uniq);
diff --git a/src/uu/uniq/src/uniq.rs b/src/uu/uniq/src/uniq.rs
index c6c6a444d..020de0230 100644
--- a/src/uu/uniq/src/uniq.rs
+++ b/src/uu/uniq/src/uniq.rs
@@ -5,7 +5,7 @@
 //  * For the full copyright and license information, please view the LICENSE
 //  * file that was distributed with this source code.
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 use std::fs::File;
 use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
 use std::path::Path;
@@ -13,8 +13,10 @@ use std::str::FromStr;
 use strum_macros::{AsRefStr, EnumString};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::format_usage;
 
 static ABOUT: &str = "Report or omit repeated lines.";
+const USAGE: &str = "{} [OPTION]... [INPUT [OUTPUT]]...";
 pub mod options {
     pub static ALL_REPEATED: &str = "all-repeated";
     pub static CHECK_CHARS: &str = "check-chars";
@@ -239,13 +241,6 @@ fn opt_parsed<T: FromStr>(opt_name: &str, matches: &ArgMatches) -> UResult<Optio
     })
 }
 
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [INPUT [OUTPUT]]...",
-        uucore::execution_phrase()
-    )
-}
-
 fn get_long_usage() -> String {
     String::from(
         "Filter adjacent matching lines from INPUT (or standard input),\n\
@@ -255,15 +250,11 @@ fn get_long_usage() -> String {
     )
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
     let long_usage = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&long_usage[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&long_usage[..]).get_matches_from(args);
 
     let files: Vec<String> = matches
         .values_of(ARG_FILES)
@@ -294,21 +285,25 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         zero_terminated: matches.is_present(options::ZERO_TERMINATED),
     };
     uniq.print_uniq(
-        &mut open_input_file(in_file_name)?,
-        &mut open_output_file(out_file_name)?,
+        &mut open_input_file(&in_file_name)?,
+        &mut open_output_file(&out_file_name)?,
     )
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::ALL_REPEATED)
-                .short("D")
+            Arg::new(options::ALL_REPEATED)
+                .short('D')
                 .long(options::ALL_REPEATED)
                 .possible_values(&[
-                    Delimiters::None.as_ref(), Delimiters::Prepend.as_ref(), Delimiters::Separate.as_ref()
+                    "none",
+                    "prepend",
+                    "separate"
                 ])
                 .help("print all duplicate lines. Delimiting is done with blank lines. [default: none]")
                 .value_name("delimit-method")
@@ -316,11 +311,13 @@ pub fn uu_app() -> App<'static, 'static> {
                 .max_values(1),
         )
         .arg(
-            Arg::with_name(options::GROUP)
+            Arg::new(options::GROUP)
                 .long(options::GROUP)
                 .possible_values(&[
-                    Delimiters::Separate.as_ref(), Delimiters::Prepend.as_ref(),
-                    Delimiters::Append.as_ref(), Delimiters::Both.as_ref()
+                    "separate",
+                    "prepend",
+                    "append",
+                    "both",
                 ])
                 .help("show all items, separating groups with an empty line. [default: separate]")
                 .value_name("group-method")
@@ -333,59 +330,59 @@ pub fn uu_app() -> App<'static, 'static> {
                 ]),
         )
         .arg(
-            Arg::with_name(options::CHECK_CHARS)
-                .short("w")
+            Arg::new(options::CHECK_CHARS)
+                .short('w')
                 .long(options::CHECK_CHARS)
                 .help("compare no more than N characters in lines")
                 .value_name("N"),
         )
         .arg(
-            Arg::with_name(options::COUNT)
-                .short("c")
+            Arg::new(options::COUNT)
+                .short('c')
                 .long(options::COUNT)
                 .help("prefix lines by the number of occurrences"),
         )
         .arg(
-            Arg::with_name(options::IGNORE_CASE)
-                .short("i")
+            Arg::new(options::IGNORE_CASE)
+                .short('i')
                 .long(options::IGNORE_CASE)
                 .help("ignore differences in case when comparing"),
         )
         .arg(
-            Arg::with_name(options::REPEATED)
-                .short("d")
+            Arg::new(options::REPEATED)
+                .short('d')
                 .long(options::REPEATED)
                 .help("only print duplicate lines"),
         )
         .arg(
-            Arg::with_name(options::SKIP_CHARS)
-                .short("s")
+            Arg::new(options::SKIP_CHARS)
+                .short('s')
                 .long(options::SKIP_CHARS)
                 .help("avoid comparing the first N characters")
                 .value_name("N"),
         )
         .arg(
-            Arg::with_name(options::SKIP_FIELDS)
-                .short("f")
+            Arg::new(options::SKIP_FIELDS)
+                .short('f')
                 .long(options::SKIP_FIELDS)
                 .help("avoid comparing the first N fields")
                 .value_name("N"),
         )
         .arg(
-            Arg::with_name(options::UNIQUE)
-                .short("u")
+            Arg::new(options::UNIQUE)
+                .short('u')
                 .long(options::UNIQUE)
                 .help("only print unique lines"),
         )
         .arg(
-            Arg::with_name(options::ZERO_TERMINATED)
-                .short("z")
+            Arg::new(options::ZERO_TERMINATED)
+                .short('z')
                 .long(options::ZERO_TERMINATED)
                 .help("end lines with 0 byte, not newline"),
         )
         .arg(
-            Arg::with_name(ARG_FILES)
-                .multiple(true)
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
                 .takes_value(true)
                 .max_values(2),
         )
@@ -396,7 +393,7 @@ fn get_delimiter(matches: &ArgMatches) -> Delimiters {
         .value_of(options::ALL_REPEATED)
         .or_else(|| matches.value_of(options::GROUP));
     if let Some(delimiter_arg) = value {
-        Delimiters::from_str(delimiter_arg).unwrap() // All possible values for ALL_REPEATED are &str's of Delimiters
+        Delimiters::from_str(delimiter_arg).unwrap() // All possible values for ALL_REPEATED are Delimiters (of type `&str`)
     } else if matches.is_present(options::GROUP) {
         Delimiters::Separate
     } else {
@@ -404,11 +401,11 @@ fn get_delimiter(matches: &ArgMatches) -> Delimiters {
     }
 }
 
-fn open_input_file(in_file_name: String) -> UResult<BufReader<Box<dyn Read + 'static>>> {
+fn open_input_file(in_file_name: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
     let in_file = if in_file_name == "-" {
         Box::new(stdin()) as Box<dyn Read>
     } else {
-        let path = Path::new(&in_file_name[..]);
+        let path = Path::new(in_file_name);
         let in_file = File::open(&path)
             .map_err_context(|| format!("Could not open {}", in_file_name.maybe_quote()))?;
         Box::new(in_file) as Box<dyn Read>
@@ -416,11 +413,11 @@ fn open_input_file(in_file_name: String) -> UResult<BufReader<Box<dyn Read + 'st
     Ok(BufReader::new(in_file))
 }
 
-fn open_output_file(out_file_name: String) -> UResult<BufWriter<Box<dyn Write + 'static>>> {
+fn open_output_file(out_file_name: &str) -> UResult<BufWriter<Box<dyn Write + 'static>>> {
     let out_file = if out_file_name == "-" {
         Box::new(stdout()) as Box<dyn Write>
     } else {
-        let path = Path::new(&out_file_name[..]);
+        let path = Path::new(out_file_name);
         let out_file = File::create(&path)
             .map_err_context(|| format!("Could not create {}", out_file_name.maybe_quote()))?;
         Box::new(out_file) as Box<dyn Write>
diff --git a/src/uu/unlink/Cargo.toml b/src/uu/unlink/Cargo.toml
index c4b7d49cb..7342fa5b4 100644
--- a/src/uu/unlink/Cargo.toml
+++ b/src/uu/unlink/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_unlink"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "unlink ~ (uutils) remove a (file system) link to FILE"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/unlink"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/unlink"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/unlink.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore" }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore" }
 
 [[bin]]
 name = "unlink"
diff --git a/src/uu/unlink/LICENSE b/src/uu/unlink/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/unlink/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/unlink/src/main.rs b/src/uu/unlink/src/main.rs
index b03d4a675..8e107866e 100644
--- a/src/uu/unlink/src/main.rs
+++ b/src/uu/unlink/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_unlink);
+uucore::bin!(uu_unlink);
diff --git a/src/uu/unlink/src/unlink.rs b/src/uu/unlink/src/unlink.rs
index 58bb5442c..fc72b4623 100644
--- a/src/uu/unlink/src/unlink.rs
+++ b/src/uu/unlink/src/unlink.rs
@@ -10,7 +10,7 @@
 use std::fs::remove_file;
 use std::path::Path;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
@@ -18,7 +18,7 @@ use uucore::error::{FromIo, UResult};
 static ABOUT: &str = "Unlink the file at FILE.";
 static OPT_PATH: &str = "FILE";
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().get_matches_from(args);
 
@@ -27,9 +27,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     remove_file(path).map_err_context(|| format!("cannot unlink {}", path.quote()))
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .arg(Arg::with_name(OPT_PATH).required(true).hidden(true))
+        .infer_long_args(true)
+        .arg(
+            Arg::new(OPT_PATH)
+                .required(true)
+                .hide(true)
+                .allow_invalid_utf8(true),
+        )
 }
diff --git a/src/uu/uptime/Cargo.toml b/src/uu/uptime/Cargo.toml
index 785955afc..b199fb24a 100644
--- a/src/uu/uptime/Cargo.toml
+++ b/src/uu/uptime/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_uptime"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uptime ~ (uutils) display dynamic system information"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/uptime"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/uptime"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,10 +15,9 @@ edition = "2018"
 path = "src/uptime.rs"
 
 [dependencies]
-chrono = "0.4"
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["libc", "utmpx"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+chrono = "^0.4.11"
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["libc", "utmpx"] }
 
 [[bin]]
 name = "uptime"
diff --git a/src/uu/uptime/LICENSE b/src/uu/uptime/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/uptime/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/uptime/src/main.rs b/src/uu/uptime/src/main.rs
index be5d5ab01..960886b86 100644
--- a/src/uu/uptime/src/main.rs
+++ b/src/uu/uptime/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_uptime);
+uucore::bin!(uu_uptime);
diff --git a/src/uu/uptime/src/uptime.rs b/src/uu/uptime/src/uptime.rs
index eabcd1abf..a93344dbc 100644
--- a/src/uu/uptime/src/uptime.rs
+++ b/src/uu/uptime/src/uptime.rs
@@ -9,8 +9,9 @@
 // spell-checker:ignore (ToDO) getloadavg upsecs updays nusers loadavg boottime uphours upmins
 
 use chrono::{Local, TimeZone, Utc};
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 
+use uucore::format_usage;
 // import crate time from utmpx
 pub use uucore::libc;
 use uucore::libc::time_t;
@@ -20,6 +21,7 @@ use uucore::error::{UResult, USimpleError};
 static ABOUT: &str = "Display the current time, the length of time the system has been up,\n\
                       the number of users on the system, and the average number of jobs\n\
                       in the run queue over the last 1, 5 and 15 minutes.";
+const USAGE: &str = "{} [OPTION]...";
 pub mod options {
     pub static SINCE: &str = "since";
 }
@@ -32,14 +34,9 @@ extern "C" {
     fn GetTickCount() -> uucore::libc::uint32_t;
 }
 
-fn usage() -> String {
-    format!("{0} [OPTION]...", uucore::execution_phrase())
-}
-
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
+    let matches = uu_app().get_matches_from(args);
 
     let (boot_time, user_count) = process_utmpx();
     let uptime = get_uptime(boot_time);
@@ -62,13 +59,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::SINCE)
-                .short("s")
+            Arg::new(options::SINCE)
+                .short('s')
                 .long(options::SINCE)
                 .help("system up since"),
         )
@@ -177,7 +176,7 @@ fn print_uptime(upsecs: i64) {
     match updays.cmp(&1) {
         std::cmp::Ordering::Equal => print!("up {:1} day, {:2}:{:02},  ", updays, uphours, upmins),
         std::cmp::Ordering::Greater => {
-            print!("up {:1} days, {:2}:{:02},  ", updays, uphours, upmins)
+            print!("up {:1} days, {:2}:{:02},  ", updays, uphours, upmins);
         }
         _ => print!("up  {:2}:{:02}, ", uphours, upmins),
     };
diff --git a/src/uu/users/Cargo.toml b/src/uu/users/Cargo.toml
index 05872e8bf..3b660f304 100644
--- a/src/uu/users/Cargo.toml
+++ b/src/uu/users/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_users"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "users ~ (uutils) display names of currently logged-in users"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/users"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/users"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/users.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["utmpx"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["utmpx"] }
 
 [[bin]]
 name = "users"
diff --git a/src/uu/users/LICENSE b/src/uu/users/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/users/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/users/src/main.rs b/src/uu/users/src/main.rs
index f30a01ecb..eab36c2e3 100644
--- a/src/uu/users/src/main.rs
+++ b/src/uu/users/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_users);
+uucore::bin!(uu_users);
diff --git a/src/uu/users/src/users.rs b/src/uu/users/src/users.rs
index d0768d8d1..79fac3b68 100644
--- a/src/uu/users/src/users.rs
+++ b/src/uu/users/src/users.rs
@@ -10,18 +10,16 @@
 
 use std::path::Path;
 
-use clap::{crate_version, App, Arg};
+use clap::{crate_version, Arg, Command};
 use uucore::error::UResult;
+use uucore::format_usage;
 use uucore::utmpx::{self, Utmpx};
 
 static ABOUT: &str = "Print the user names of users currently logged in to the current host";
+const USAGE: &str = "{} [FILE]";
 
 static ARG_FILES: &str = "files";
 
-fn usage() -> String {
-    format!("{0} [FILE]", uucore::execution_phrase())
-}
-
 fn get_long_usage() -> String {
     format!(
         "Output who is currently logged in according to FILE.
@@ -30,15 +28,11 @@ If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.",
     )
 }
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let usage = usage();
     let after_help = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let files: Vec<&Path> = matches
         .values_of_os(ARG_FILES)
@@ -64,9 +58,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
-        .arg(Arg::with_name(ARG_FILES).takes_value(true).max_values(1))
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .arg(Arg::new(ARG_FILES).takes_value(true).max_values(1))
 }
diff --git a/src/uu/wc/Cargo.toml b/src/uu/wc/Cargo.toml
index d76e0b176..02b009dde 100644
--- a/src/uu/wc/Cargo.toml
+++ b/src/uu/wc/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_wc"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "wc ~ (uutils) display newline, word, and byte counts for input"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/wc"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/wc"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,21 +15,16 @@ edition = "2018"
 path = "src/wc.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["pipes"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["pipes"] }
 bytecount = "0.6.2"
 utf-8 = "0.7.6"
 unicode-width = "0.1.8"
 
 [target.'cfg(unix)'.dependencies]
-nix = "0.20"
+nix = "0.23.1"
 libc = "0.2"
 
 [[bin]]
 name = "wc"
 path = "src/main.rs"
-
-[package.metadata.cargo-udeps.ignore]
-# Necessary for "make all"
-normal = ["uucore_procs"]
diff --git a/src/uu/wc/LICENSE b/src/uu/wc/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/wc/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/wc/src/count_fast.rs b/src/uu/wc/src/count_fast.rs
index e4f6be6c1..4515cd3d7 100644
--- a/src/uu/wc/src/count_fast.rs
+++ b/src/uu/wc/src/count_fast.rs
@@ -80,7 +80,13 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
         if let Ok(stat) = stat::fstat(fd) {
             // If the file is regular, then the `st_size` should hold
             // the file's size in bytes.
-            if (stat.st_mode & S_IFREG) != 0 {
+            // 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 & S_IFREG) != 0 && stat.st_size > 0 {
                 return (stat.st_size as usize, None);
             }
             #[cfg(any(target_os = "linux", target_os = "android"))]
diff --git a/src/uu/wc/src/countable.rs b/src/uu/wc/src/countable.rs
index a14623559..5596decb3 100644
--- a/src/uu/wc/src/countable.rs
+++ b/src/uu/wc/src/countable.rs
@@ -1,7 +1,7 @@
 //! Traits and implementations for iterating over lines in a file-like object.
 //!
 //! This module provides a [`WordCountable`] trait and implementations
-//! for some common file-like objects. Use the [`WordCountable::lines`]
+//! for some common file-like objects. Use the [`WordCountable::buffered`]
 //! method to get an iterator over lines of a file-like object.
 use std::fs::File;
 use std::io::{BufRead, BufReader, Read, StdinLock};
diff --git a/src/uu/wc/src/main.rs b/src/uu/wc/src/main.rs
index b58b9cac7..a89861765 100644
--- a/src/uu/wc/src/main.rs
+++ b/src/uu/wc/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_wc);
+uucore::bin!(uu_wc);
diff --git a/src/uu/wc/src/wc.rs b/src/uu/wc/src/wc.rs
index 16522a0a7..968830c48 100644
--- a/src/uu/wc/src/wc.rs
+++ b/src/uu/wc/src/wc.rs
@@ -15,16 +15,21 @@ use count_fast::{count_bytes_and_lines_fast, count_bytes_fast};
 use countable::WordCountable;
 use unicode_width::UnicodeWidthChar;
 use utf8::{BufReadDecoder, BufReadDecoderError};
+use uucore::format_usage;
 use word_count::{TitledWordCount, WordCount};
 
-use clap::{crate_version, App, Arg, ArgMatches};
+use clap::{crate_version, Arg, ArgMatches, Command};
 
 use std::cmp::max;
+use std::error::Error;
+use std::ffi::OsStr;
+use std::fmt::Display;
 use std::fs::{self, File};
-use std::io::{self, Write};
+use std::io::{self, Read, Write};
 use std::path::{Path, PathBuf};
 
 use uucore::display::{Quotable, Quoted};
+use uucore::error::{UError, UResult, USimpleError};
 
 /// The minimum character width for formatting counts when reading from stdin.
 const MINIMUM_WIDTH: usize = 7;
@@ -38,8 +43,8 @@ struct Settings {
 }
 
 impl Settings {
-    fn new(matches: &ArgMatches) -> Settings {
-        let settings = Settings {
+    fn new(matches: &ArgMatches) -> Self {
+        let settings = Self {
             show_bytes: matches.is_present(options::BYTES),
             show_chars: matches.is_present(options::CHAR),
             show_lines: matches.is_present(options::LINES),
@@ -56,7 +61,7 @@ impl Settings {
             return settings;
         }
 
-        Settings {
+        Self {
             show_bytes: true,
             show_chars: false,
             show_lines: true,
@@ -77,25 +82,20 @@ impl Settings {
 }
 
 static ABOUT: &str = "Display newline, word, and byte counts for each FILE, and a total line if
-more than one FILE is specified.";
+more than one FILE is specified. With no FILE, or when FILE is -, read standard input.";
+const USAGE: &str = "{} [OPTION]... [FILE]...";
 
 pub mod options {
     pub static BYTES: &str = "bytes";
     pub static CHAR: &str = "chars";
+    pub static FILES0_FROM: &str = "files0-from";
     pub static LINES: &str = "lines";
     pub static MAX_LINE_LENGTH: &str = "max-line-length";
     pub static WORDS: &str = "words";
 }
 
 static ARG_FILES: &str = "files";
-
-fn usage() -> String {
-    format!(
-        "{0} [OPTION]... [FILE]...
- With no FILE, or when FILE is -, read standard input.",
-        uucore::execution_phrase()
-    )
-}
+static STDIN_REPR: &str = "-";
 
 enum StdinKind {
     /// Stdin specified on command-line with "-".
@@ -114,12 +114,22 @@ enum Input {
     Stdin(StdinKind),
 }
 
+impl From<&OsStr> for Input {
+    fn from(input: &OsStr) -> Self {
+        if input == STDIN_REPR {
+            Self::Stdin(StdinKind::Explicit)
+        } else {
+            Self::Path(input.into())
+        }
+    }
+}
+
 impl Input {
     /// Converts input to title that appears in stats.
     fn to_title(&self) -> Option<&Path> {
         match self {
             Input::Path(path) => Some(path),
-            Input::Stdin(StdinKind::Explicit) => Some("-".as_ref()),
+            Input::Stdin(StdinKind::Explicit) => Some(STDIN_REPR.as_ref()),
             Input::Stdin(StdinKind::Implicit) => None,
         }
     }
@@ -132,73 +142,141 @@ impl Input {
     }
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
-    let usage = usage();
+#[derive(Debug)]
+enum WcError {
+    FilesDisabled(String),
+    StdinReprNotAllowed(String),
+}
 
-    let matches = uu_app().usage(&usage[..]).get_matches_from(args);
-
-    let mut inputs: Vec<Input> = matches
-        .values_of_os(ARG_FILES)
-        .map(|v| {
-            v.map(|i| {
-                if i == "-" {
-                    Input::Stdin(StdinKind::Explicit)
-                } else {
-                    Input::Path(i.into())
-                }
-            })
-            .collect()
-        })
-        .unwrap_or_default();
-
-    if inputs.is_empty() {
-        inputs.push(Input::Stdin(StdinKind::Implicit));
+impl UError for WcError {
+    fn code(&self) -> i32 {
+        match self {
+            WcError::FilesDisabled(_) | WcError::StdinReprNotAllowed(_) => 1,
+        }
     }
 
-    let settings = Settings::new(&matches);
-
-    if wc(inputs, &settings).is_ok() {
-        0
-    } else {
-        1
+    fn usage(&self) -> bool {
+        matches!(self, WcError::FilesDisabled(_))
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+impl Error for WcError {}
+
+impl Display for WcError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WcError::FilesDisabled(message) | WcError::StdinReprNotAllowed(message) => {
+                write!(f, "{}", message)
+            }
+        }
+    }
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().get_matches_from(args);
+
+    let inputs = inputs(&matches)?;
+
+    let settings = Settings::new(&matches);
+
+    wc(&inputs, &settings)
+}
+
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::BYTES)
-                .short("c")
+            Arg::new(options::BYTES)
+                .short('c')
                 .long(options::BYTES)
                 .help("print the byte counts"),
         )
         .arg(
-            Arg::with_name(options::CHAR)
-                .short("m")
+            Arg::new(options::CHAR)
+                .short('m')
                 .long(options::CHAR)
                 .help("print the character counts"),
         )
         .arg(
-            Arg::with_name(options::LINES)
-                .short("l")
+            Arg::new(options::FILES0_FROM)
+                .long(options::FILES0_FROM)
+                .takes_value(true)
+                .value_name("F")
+                .help(
+                    "read input from the files specified by
+    NUL-terminated names in file F;
+    If F is - then read names from standard input",
+                ),
+        )
+        .arg(
+            Arg::new(options::LINES)
+                .short('l')
                 .long(options::LINES)
                 .help("print the newline counts"),
         )
         .arg(
-            Arg::with_name(options::MAX_LINE_LENGTH)
-                .short("L")
+            Arg::new(options::MAX_LINE_LENGTH)
+                .short('L')
                 .long(options::MAX_LINE_LENGTH)
                 .help("print the length of the longest line"),
         )
         .arg(
-            Arg::with_name(options::WORDS)
-                .short("w")
+            Arg::new(options::WORDS)
+                .short('w')
                 .long(options::WORDS)
                 .help("print the word counts"),
         )
-        .arg(Arg::with_name(ARG_FILES).multiple(true).takes_value(true))
+        .arg(
+            Arg::new(ARG_FILES)
+                .multiple_occurrences(true)
+                .takes_value(true)
+                .allow_invalid_utf8(true),
+        )
+}
+
+fn inputs(matches: &ArgMatches) -> UResult<Vec<Input>> {
+    match matches.values_of_os(ARG_FILES) {
+        Some(os_values) => {
+            if matches.is_present(options::FILES0_FROM) {
+                return Err(WcError::FilesDisabled(
+                    "file operands cannot be combined with --files0-from".into(),
+                )
+                .into());
+            }
+
+            Ok(os_values.map(Input::from).collect())
+        }
+        None => match matches.value_of(options::FILES0_FROM) {
+            Some(files_0_from) => create_paths_from_files0(files_0_from),
+            None => Ok(vec![Input::Stdin(StdinKind::Implicit)]),
+        },
+    }
+}
+
+fn create_paths_from_files0(files_0_from: &str) -> UResult<Vec<Input>> {
+    let mut paths = String::new();
+    let read_from_stdin = files_0_from == STDIN_REPR;
+
+    if read_from_stdin {
+        io::stdin().lock().read_to_string(&mut paths)?;
+    } else {
+        File::open(files_0_from)?.read_to_string(&mut paths)?;
+    }
+
+    let paths: Vec<&str> = paths.split_terminator('\0').collect();
+
+    if read_from_stdin && paths.contains(&STDIN_REPR) {
+        return Err(WcError::StdinReprNotAllowed(
+            "when reading file names from stdin, no file name of '-' allowed".into(),
+        )
+        .into());
+    }
+
+    Ok(paths.iter().map(OsStr::new).map(Input::from).collect())
 }
 
 fn word_count_from_reader<T: WordCountable>(
@@ -249,12 +327,7 @@ fn word_count_from_reader<T: WordCountable>(
                     }
                     if settings.show_max_line_length {
                         match ch {
-                            '\n' => {
-                                total.max_line_length = max(current_len, total.max_line_length);
-                                current_len = 0;
-                            }
-                            // '\x0c' = '\f'
-                            '\r' | '\x0c' => {
+                            '\n' | '\r' | '\x0c' => {
                                 total.max_line_length = max(current_len, total.max_line_length);
                                 current_len = 0;
                             }
@@ -326,59 +399,6 @@ fn word_count_from_input(input: &Input, settings: &Settings) -> CountResult {
     }
 }
 
-/// Print a message appropriate for the particular error to `stderr`.
-///
-/// # Examples
-///
-/// This will print `wc: /tmp: Is a directory` to `stderr`.
-///
-/// ```rust,ignore
-/// show_error(Input::Path("/tmp"), WcError::IsDirectory("/tmp"))
-/// ```
-fn show_error(input: &Input, err: io::Error) {
-    show_error!("{}: {}", input.path_display(), err);
-}
-
-/// Compute the number of digits needed to represent any count for this input.
-///
-/// If `input` is [`Input::Stdin`], then this function returns
-/// [`MINIMUM_WIDTH`]. Otherwise, if metadata could not be read from
-/// `input` then this function returns 1.
-///
-/// # Errors
-///
-/// This function will return an error if `input` is a [`Input::Path`]
-/// and there is a problem accessing the metadata of the given `input`.
-///
-/// # Examples
-///
-/// A [`Input::Stdin`] gets a default minimum width:
-///
-/// ```rust,ignore
-/// let input = Input::Stdin(StdinKind::Explicit);
-/// assert_eq!(7, digit_width(input));
-/// ```
-fn digit_width(input: &Input) -> io::Result<usize> {
-    match input {
-        Input::Stdin(_) => Ok(MINIMUM_WIDTH),
-        Input::Path(filename) => {
-            let path = Path::new(filename);
-            let metadata = fs::metadata(path)?;
-            if metadata.is_file() {
-                // TODO We are now computing the number of bytes in a file
-                // twice: once here and once in `WordCount::from_line()` (or
-                // in `count_bytes_fast()` if that function is called
-                // instead). See GitHub issue #2201.
-                let num_bytes = metadata.len();
-                let num_digits = num_bytes.to_string().len();
-                Ok(num_digits)
-            } else {
-                Ok(MINIMUM_WIDTH)
-            }
-        }
-    }
-}
-
 /// Compute the number of digits needed to represent all counts in all inputs.
 ///
 /// `inputs` may include zero or more [`Input::Stdin`] entries, each of
@@ -386,152 +406,126 @@ fn digit_width(input: &Input) -> io::Result<usize> {
 /// entry causes this function to return a width that is at least
 /// [`MINIMUM_WIDTH`].
 ///
-/// If `input` is empty, then this function returns 1. If file metadata
-/// could not be read from any of the [`Input::Path`] inputs and there
-/// are no [`Input::Stdin`] inputs, then this function returns 1.
+/// If `input` is empty, or if only one number needs to be printed (for just
+/// one file) then this function is optimized to return 1 without making any
+/// calls to get file metadata.
 ///
-/// If there is a problem accessing the metadata, this function will
-/// silently ignore the error and assume that the number of digits
-/// needed to display the counts for that file is 1.
+/// If file metadata could not be read from any of the [`Input::Path`] input,
+/// that input does not affect number width computation
 ///
-/// # Examples
-///
-/// An empty slice implies a width of 1:
-///
-/// ```rust,ignore
-/// assert_eq!(1, max_width(&vec![]));
-/// ```
-///
-/// The presence of [`Input::Stdin`] implies a minimum width:
-///
-/// ```rust,ignore
-/// let inputs = vec![Input::Stdin(StdinKind::Explicit)];
-/// assert_eq!(7, max_width(&inputs));
-/// ```
-fn max_width(inputs: &[Input]) -> usize {
-    let mut result = 1;
+/// Otherwise, the file sizes in the file metadata are summed and the number of
+/// digits in that total size is returned as the number width
+fn compute_number_width(inputs: &[Input], settings: &Settings) -> usize {
+    if inputs.is_empty() || (inputs.len() == 1 && settings.number_enabled() == 1) {
+        return 1;
+    }
+
+    let mut minimum_width = 1;
+    let mut total = 0;
+
     for input in inputs {
-        if let Ok(n) = digit_width(input) {
-            result = result.max(n);
+        match input {
+            Input::Stdin(_) => {
+                minimum_width = MINIMUM_WIDTH;
+            }
+            Input::Path(path) => {
+                if let Ok(meta) = fs::metadata(path) {
+                    if meta.is_file() {
+                        total += meta.len();
+                    } else {
+                        minimum_width = MINIMUM_WIDTH;
+                    }
+                }
+            }
         }
     }
-    result
+
+    max(minimum_width, total.to_string().len())
 }
 
-fn wc(inputs: Vec<Input>, settings: &Settings) -> Result<(), u32> {
-    // Compute the width, in digits, to use when formatting counts.
-    //
-    // The width is the number of digits needed to print the number of
-    // bytes in the largest file. This is true regardless of whether
-    // the `settings` indicate that the bytes will be displayed.
-    //
-    // If we only need to display a single number, set this to 0 to
-    // prevent leading spaces.
-    let mut failure = false;
-    let max_width = if settings.number_enabled() <= 1 {
-        0
-    } else {
-        max_width(&inputs)
-    };
+fn wc(inputs: &[Input], settings: &Settings) -> UResult<()> {
+    let number_width = compute_number_width(inputs, settings);
 
     let mut total_word_count = WordCount::default();
 
     let num_inputs = inputs.len();
 
-    for input in &inputs {
+    for input in inputs {
         let word_count = match word_count_from_input(input, settings) {
             CountResult::Success(word_count) => word_count,
             CountResult::Interrupted(word_count, error) => {
-                show_error(input, error);
-                failure = true;
+                show!(USimpleError::new(
+                    1,
+                    format!("{}: {}", input.path_display(), error)
+                ));
                 word_count
             }
             CountResult::Failure(error) => {
-                show_error(input, error);
-                failure = true;
+                show!(USimpleError::new(
+                    1,
+                    format!("{}: {}", input.path_display(), error)
+                ));
                 continue;
             }
         };
         total_word_count += word_count;
         let result = word_count.with_title(input.to_title());
-        if let Err(err) = print_stats(settings, &result, max_width) {
-            show_warning!(
-                "failed to print result for {}: {}",
-                result
-                    .title
-                    .unwrap_or_else(|| "<stdin>".as_ref())
-                    .maybe_quote(),
-                err
-            );
-            failure = true;
+        if let Err(err) = print_stats(settings, &result, number_width) {
+            show!(USimpleError::new(
+                1,
+                format!(
+                    "failed to print result for {}: {}",
+                    result
+                        .title
+                        .unwrap_or_else(|| "<stdin>".as_ref())
+                        .maybe_quote(),
+                    err,
+                ),
+            ));
         }
     }
 
     if num_inputs > 1 {
         let total_result = total_word_count.with_title(Some("total".as_ref()));
-        if let Err(err) = print_stats(settings, &total_result, max_width) {
-            show_warning!("failed to print total: {}", err);
-            failure = true;
+        if let Err(err) = print_stats(settings, &total_result, number_width) {
+            show!(USimpleError::new(
+                1,
+                format!("failed to print total: {}", err)
+            ));
         }
     }
 
-    if failure {
-        Err(1)
-    } else {
-        Ok(())
-    }
+    // Although this appears to be returning `Ok`, the exit code may
+    // have been set to a non-zero value by a call to `show!()` above.
+    Ok(())
 }
 
-fn print_stats(settings: &Settings, result: &TitledWordCount, min_width: usize) -> io::Result<()> {
-    let stdout = io::stdout();
-    let mut stdout_lock = stdout.lock();
-
-    let mut is_first: bool = true;
+fn print_stats(
+    settings: &Settings,
+    result: &TitledWordCount,
+    number_width: usize,
+) -> io::Result<()> {
+    let mut columns = Vec::new();
 
     if settings.show_lines {
-        if !is_first {
-            write!(stdout_lock, " ")?;
-        }
-        write!(stdout_lock, "{:1$}", result.count.lines, min_width)?;
-        is_first = false;
+        columns.push(format!("{:1$}", result.count.lines, number_width));
     }
     if settings.show_words {
-        if !is_first {
-            write!(stdout_lock, " ")?;
-        }
-        write!(stdout_lock, "{:1$}", result.count.words, min_width)?;
-        is_first = false;
+        columns.push(format!("{:1$}", result.count.words, number_width));
     }
     if settings.show_chars {
-        if !is_first {
-            write!(stdout_lock, " ")?;
-        }
-        write!(stdout_lock, "{:1$}", result.count.chars, min_width)?;
-        is_first = false;
+        columns.push(format!("{:1$}", result.count.chars, number_width));
     }
     if settings.show_bytes {
-        if !is_first {
-            write!(stdout_lock, " ")?;
-        }
-        write!(stdout_lock, "{:1$}", result.count.bytes, min_width)?;
-        is_first = false;
+        columns.push(format!("{:1$}", result.count.bytes, number_width));
     }
     if settings.show_max_line_length {
-        if !is_first {
-            write!(stdout_lock, " ")?;
-        }
-        write!(
-            stdout_lock,
-            "{:1$}",
-            result.count.max_line_length, min_width
-        )?;
+        columns.push(format!("{:1$}", result.count.max_line_length, number_width));
     }
 
     if let Some(title) = result.title {
-        writeln!(stdout_lock, " {}", title.maybe_quote())?;
-    } else {
-        writeln!(stdout_lock)?;
+        columns.push(title.maybe_quote().to_string());
     }
 
-    Ok(())
+    writeln!(io::stdout().lock(), "{}", columns.join(" "))
 }
diff --git a/src/uu/wc/src/word_count.rs b/src/uu/wc/src/word_count.rs
index 617b811fc..c1dd0c3d3 100644
--- a/src/uu/wc/src/word_count.rs
+++ b/src/uu/wc/src/word_count.rs
@@ -27,7 +27,7 @@ impl Add for WordCount {
 
 impl AddAssign for WordCount {
     fn add_assign(&mut self, other: Self) {
-        *self = *self + other
+        *self = *self + other;
     }
 }
 
diff --git a/src/uu/who/Cargo.toml b/src/uu/who/Cargo.toml
index c660be59d..aa9ba27d6 100644
--- a/src/uu/who/Cargo.toml
+++ b/src/uu/who/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_who"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "who ~ (uutils) display information about currently logged-in users"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/who"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/who"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,9 +15,8 @@ edition = "2018"
 path = "src/who.rs"
 
 [dependencies]
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["utmpx"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
-clap = { version = "2.33", features = ["wrap_help"] }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["utmpx"] }
 
 [[bin]]
 name = "who"
diff --git a/src/uu/who/LICENSE b/src/uu/who/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/who/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/who/src/main.rs b/src/uu/who/src/main.rs
index a093201a1..59edbba77 100644
--- a/src/uu/who/src/main.rs
+++ b/src/uu/who/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_who);
+uucore::bin!(uu_who);
diff --git a/src/uu/who/src/who.rs b/src/uu/who/src/who.rs
index a975c82ba..98ef06f47 100644
--- a/src/uu/who/src/who.rs
+++ b/src/uu/who/src/who.rs
@@ -7,17 +7,17 @@
 
 // spell-checker:ignore (ToDO) ttyname hostnames runlevel mesg wtmp statted boottime deadprocs initspawn clockchange curr runlvline pidstr exitstr hoststr
 
-#[macro_use]
-extern crate uucore;
+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, App, Arg};
+use clap::{crate_version, Arg, Command};
 use std::borrow::Cow;
 use std::ffi::CStr;
 use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
-use uucore::InvalidEncodingHandling;
+use uucore::{format_usage, InvalidEncodingHandling};
 
 mod options {
     pub const ALL: &str = "all";
@@ -38,19 +38,13 @@ mod options {
 }
 
 static ABOUT: &str = "Print information about users who are currently logged in.";
+const USAGE: &str = "{} [OPTION]... [ FILE | ARG1 ARG2 ]";
 
 #[cfg(any(target_os = "linux"))]
 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 usage() -> String {
-    format!(
-        "{0} [OPTION]... [ FILE | ARG1 ARG2 ]",
-        uucore::execution_phrase()
-    )
-}
-
 fn get_long_usage() -> String {
     format!(
         "If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.\n\
@@ -59,18 +53,15 @@ fn get_long_usage() -> String {
     )
 }
 
-pub fn uumain(args: impl uucore::Args) -> i32 {
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args
         .collect_str(InvalidEncodingHandling::Ignore)
         .accept_any();
 
-    let usage = usage();
     let after_help = get_long_usage();
 
-    let matches = uu_app()
-        .usage(&usage[..])
-        .after_help(&after_help[..])
-        .get_matches_from(args);
+    let matches = uu_app().after_help(&after_help[..]).get_matches_from(args);
 
     let files: Vec<String> = matches
         .values_of(options::FILE)
@@ -157,106 +148,106 @@ pub fn uumain(args: impl uucore::Args) -> i32 {
         args: files,
     };
 
-    who.exec();
-
-    0
+    who.exec()
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
         .arg(
-            Arg::with_name(options::ALL)
+            Arg::new(options::ALL)
                 .long(options::ALL)
-                .short("a")
+                .short('a')
                 .help("same as -b -d --login -p -r -t -T -u"),
         )
         .arg(
-            Arg::with_name(options::BOOT)
+            Arg::new(options::BOOT)
                 .long(options::BOOT)
-                .short("b")
+                .short('b')
                 .help("time of last system boot"),
         )
         .arg(
-            Arg::with_name(options::DEAD)
+            Arg::new(options::DEAD)
                 .long(options::DEAD)
-                .short("d")
+                .short('d')
                 .help("print dead processes"),
         )
         .arg(
-            Arg::with_name(options::HEADING)
+            Arg::new(options::HEADING)
                 .long(options::HEADING)
-                .short("H")
+                .short('H')
                 .help("print line of column headings"),
         )
         .arg(
-            Arg::with_name(options::LOGIN)
+            Arg::new(options::LOGIN)
                 .long(options::LOGIN)
-                .short("l")
+                .short('l')
                 .help("print system login processes"),
         )
         .arg(
-            Arg::with_name(options::LOOKUP)
+            Arg::new(options::LOOKUP)
                 .long(options::LOOKUP)
                 .help("attempt to canonicalize hostnames via DNS"),
         )
         .arg(
-            Arg::with_name(options::ONLY_HOSTNAME_USER)
-                .short("m")
+            Arg::new(options::ONLY_HOSTNAME_USER)
+                .short('m')
                 .help("only hostname and user associated with stdin"),
         )
         .arg(
-            Arg::with_name(options::PROCESS)
+            Arg::new(options::PROCESS)
                 .long(options::PROCESS)
-                .short("p")
+                .short('p')
                 .help("print active processes spawned by init"),
         )
         .arg(
-            Arg::with_name(options::COUNT)
+            Arg::new(options::COUNT)
                 .long(options::COUNT)
-                .short("q")
+                .short('q')
                 .help("all login names and number of users logged on"),
         )
         .arg(
-            Arg::with_name(options::RUNLEVEL)
+            Arg::new(options::RUNLEVEL)
                 .long(options::RUNLEVEL)
-                .short("r")
+                .short('r')
                 .help(RUNLEVEL_HELP),
         )
         .arg(
-            Arg::with_name(options::SHORT)
+            Arg::new(options::SHORT)
                 .long(options::SHORT)
-                .short("s")
+                .short('s')
                 .help("print only name, line, and time (default)"),
         )
         .arg(
-            Arg::with_name(options::TIME)
+            Arg::new(options::TIME)
                 .long(options::TIME)
-                .short("t")
+                .short('t')
                 .help("print last system clock change"),
         )
         .arg(
-            Arg::with_name(options::USERS)
+            Arg::new(options::USERS)
                 .long(options::USERS)
-                .short("u")
+                .short('u')
                 .help("list users logged in"),
         )
         .arg(
-            Arg::with_name(options::MESG)
+            Arg::new(options::MESG)
                 .long(options::MESG)
-                .short("T")
+                .short('T')
                 // .visible_short_alias('w')  // TODO: requires clap "3.0.0-beta.2"
                 .visible_aliases(&["message", "writable"])
                 .help("add user's message status as +, - or ?"),
         )
         .arg(
-            Arg::with_name("w") // work around for `Arg::visible_short_alias`
-                .short("w")
+            Arg::new("w") // work around for `Arg::visible_short_alias`
+                .short('w')
                 .help("same as -T"),
         )
         .arg(
-            Arg::with_name(options::FILE)
+            Arg::new(options::FILE)
                 .takes_value(true)
                 .min_values(1)
                 .max_values(2),
@@ -326,7 +317,7 @@ fn current_tty() -> String {
 }
 
 impl Who {
-    fn exec(&mut self) {
+    fn exec(&mut self) -> UResult<()> {
         let run_level_chk = |_record: i16| {
             #[cfg(not(target_os = "linux"))]
             return false;
@@ -351,7 +342,7 @@ impl Who {
             let records = Utmpx::iter_all_records_from(f).peekable();
 
             if self.include_heading {
-                self.print_heading()
+                self.print_heading();
             }
             let cur_tty = if self.my_line_only {
                 current_tty()
@@ -362,7 +353,7 @@ impl Who {
             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);
+                        self.print_user(&ut)?;
                     } else if self.need_runlevel && run_level_chk(ut.record_type()) {
                         if cfg!(target_os = "linux") {
                             self.print_runlevel(&ut);
@@ -383,6 +374,7 @@ impl Who {
                 if ut.record_type() == utmpx::BOOT_TIME {}
             }
         }
+        Ok(())
     }
 
     #[inline]
@@ -464,7 +456,7 @@ impl Who {
         self.print_line("", ' ', "system boot", &time_string(ut), "", "", "", "");
     }
 
-    fn print_user(&self, ut: &Utmpx) {
+    fn print_user(&self, ut: &Utmpx) -> UResult<()> {
         let mut p = PathBuf::from("/dev");
         p.push(ut.tty_device().as_str());
         let mesg;
@@ -491,7 +483,13 @@ impl Who {
         };
 
         let s = if self.do_lookup {
-            crash_if_err!(1, ut.canon_host())
+            ut.canon_host().map_err_context(|| {
+                let host = ut.host();
+                format!(
+                    "failed to canonicalize {}",
+                    host.split(':').next().unwrap_or(&host).quote()
+                )
+            })?
         } else {
             ut.host()
         };
@@ -507,6 +505,8 @@ impl Who {
             hoststr.as_str(),
             "",
         );
+
+        Ok(())
     }
 
     #[allow(clippy::too_many_arguments)]
diff --git a/src/uu/whoami/Cargo.toml b/src/uu/whoami/Cargo.toml
index 5af93579f..67893b185 100644
--- a/src/uu/whoami/Cargo.toml
+++ b/src/uu/whoami/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_whoami"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "whoami ~ (uutils) display user name of current effective user ID"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/whoami"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/whoami"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,15 +15,14 @@ edition = "2018"
 path = "src/whoami.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["entries"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["entries"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version = "0.3", features = ["lmcons"] }
 
 [target.'cfg(unix)'.dependencies]
-libc = "0.2.42"
+libc = "0.2.121"
 
 [[bin]]
 name = "whoami"
diff --git a/src/uu/whoami/LICENSE b/src/uu/whoami/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/whoami/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/whoami/src/main.rs b/src/uu/whoami/src/main.rs
index 40de26564..7e9d7276a 100644
--- a/src/uu/whoami/src/main.rs
+++ b/src/uu/whoami/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_whoami);
+uucore::bin!(uu_whoami);
diff --git a/src/uu/whoami/src/whoami.rs b/src/uu/whoami/src/whoami.rs
index 0820588ee..770802764 100644
--- a/src/uu/whoami/src/whoami.rs
+++ b/src/uu/whoami/src/whoami.rs
@@ -10,7 +10,7 @@
 #[macro_use]
 extern crate clap;
 
-use clap::App;
+use clap::Command;
 
 use uucore::display::println_verbatim;
 use uucore::error::{FromIo, UResult};
@@ -19,7 +19,7 @@ mod platform;
 
 static ABOUT: &str = "Print the current username.";
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     uu_app().get_matches_from(args);
     let username = platform::get_username().map_err_context(|| "failed to get username".into())?;
@@ -27,8 +27,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     Ok(())
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    App::new(uucore::util_name())
+pub fn uu_app<'a>() -> Command<'a> {
+    Command::new(uucore::util_name())
         .version(crate_version!())
         .about(ABOUT)
+        .infer_long_args(true)
 }
diff --git a/src/uu/yes/Cargo.toml b/src/uu/yes/Cargo.toml
index ad8a87b46..91f6cfb3e 100644
--- a/src/uu/yes/Cargo.toml
+++ b/src/uu/yes/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uu_yes"
-version = "0.0.8"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "yes ~ (uutils) repeatedly display a line with STRING (or 'y')"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/yes"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uu/yes"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
 edition = "2018"
@@ -15,12 +15,11 @@ edition = "2018"
 path = "src/yes.rs"
 
 [dependencies]
-clap = { version = "2.33", features = ["wrap_help"] }
-uucore = { version=">=0.0.10", package="uucore", path="../../uucore", features=["pipes"] }
-uucore_procs = { version=">=0.0.7", package="uucore_procs", path="../../uucore_procs" }
+clap = { version = "3.1", features = ["wrap_help", "cargo"] }
+uucore = { version=">=0.0.11", package="uucore", path="../../uucore", features=["pipes"] }
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
-nix = "0.20.0"
+nix = "0.23.1"
 
 [[bin]]
 name = "yes"
diff --git a/src/uu/yes/LICENSE b/src/uu/yes/LICENSE
new file mode 120000
index 000000000..5853aaea5
--- /dev/null
+++ b/src/uu/yes/LICENSE
@@ -0,0 +1 @@
+../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/yes/src/main.rs b/src/uu/yes/src/main.rs
index dc5bf6a0c..8d119cf5c 100644
--- a/src/uu/yes/src/main.rs
+++ b/src/uu/yes/src/main.rs
@@ -1 +1 @@
-uucore_procs::main!(uu_yes);
+uucore::bin!(uu_yes);
diff --git a/src/uu/yes/src/splice.rs b/src/uu/yes/src/splice.rs
index 6f025d6a9..f77a09ed6 100644
--- a/src/uu/yes/src/splice.rs
+++ b/src/uu/yes/src/splice.rs
@@ -55,16 +55,13 @@ type Result<T> = std::result::Result<T, Error>;
 
 impl From<nix::Error> for Error {
     fn from(error: nix::Error) -> Self {
-        match error {
-            nix::Error::Sys(errno) => Error::Io(io::Error::from_raw_os_error(errno as i32)),
-            _ => Error::Io(io::Error::last_os_error()),
-        }
+        Self::Io(io::Error::from_raw_os_error(error as i32))
     }
 }
 
 fn maybe_unsupported(error: nix::Error) -> Error {
-    match error.as_errno() {
-        Some(Errno::EINVAL) | Some(Errno::ENOSYS) | Some(Errno::EBADF) => Error::Unsupported,
+    match error {
+        Errno::EINVAL | Errno::ENOSYS | Errno::EBADF => Error::Unsupported,
         _ => error.into(),
     }
 }
diff --git a/src/uu/yes/src/yes.rs b/src/uu/yes/src/yes.rs
index bbedc0af1..879f60579 100644
--- a/src/uu/yes/src/yes.rs
+++ b/src/uu/yes/src/yes.rs
@@ -13,17 +13,20 @@ use std::io::{self, Write};
 #[macro_use]
 extern crate clap;
 
-use clap::{App, Arg};
+use clap::{Arg, Command};
 use uucore::error::{UResult, USimpleError};
+use uucore::format_usage;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod splice;
 
+const USAGE: &str = "{} [STRING]...";
+
 // it's possible that using a smaller or larger buffer might provide better performance on some
 // systems, but honestly this is good enough
 const BUF_SIZE: usize = 16 * 1024;
 
-#[uucore_procs::gen_uumain]
+#[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().get_matches_from(args);
 
@@ -46,8 +49,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     }
 }
 
-pub fn uu_app() -> App<'static, 'static> {
-    app_from_crate!().arg(Arg::with_name("STRING").index(1).multiple(true))
+pub fn uu_app<'a>() -> Command<'a> {
+    command!()
+        .override_usage(format_usage(USAGE))
+        .arg(Arg::new("STRING").index(1).multiple_occurrences(true))
+        .infer_long_args(true)
 }
 
 fn prepare_buffer<'a>(input: &'a str, buffer: &'a mut [u8; BUF_SIZE]) -> &'a [u8] {
diff --git a/src/uucore/Cargo.toml b/src/uucore/Cargo.toml
index 952eecc28..a326402c5 100644
--- a/src/uucore/Cargo.toml
+++ b/src/uucore/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uucore"
-version = "0.0.10"
+version = "0.0.13"
 authors = ["uutils developers"]
 license = "MIT"
 description = "uutils ~ 'core' uutils code library (cross-platform)"
 
 homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/master/src/uu/arch"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uucore"
 # readme = "README.md"
 keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
 categories = ["command-line-utilities"]
@@ -16,42 +16,44 @@ edition = "2018"
 path="src/lib/lib.rs"
 
 [dependencies]
-clap = "2.33.3"
+uucore_procs = { version=">=0.0.12", path="../uucore_procs" }
+clap = "3.1"
 dns-lookup = { version="1.0.5", optional=true }
 dunce = "1.0.0"
-getopts = "<= 0.2.21"
 wild = "2.0"
 # * optional
+itertools = { version="0.10.0", optional=true }
 thiserror = { version="1.0", optional=true }
 time = { version="<= 0.1.43", optional=true }
 # * "problem" dependencies (pinned)
 data-encoding = { version="2.1", optional=true }
 data-encoding-macro = { version="0.1.12", optional=true }
 z85 = { version="3.0.3", optional=true }
-libc = { version="0.2.15", optional=true }
-once_cell = "1.8.0"
+libc = { version="0.2.121", optional=true }
+once_cell = "1.10.0"
+os_display = "0.1.0"
 
 [target.'cfg(unix)'.dependencies]
 walkdir = { version="2.3.2", optional=true }
-nix = { version="0.20", optional=true }
+nix = { version="0.23.1", optional=true }
 
 [dev-dependencies]
-clap = "2.33.3"
+clap = "3.1"
 lazy_static = "1.3"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version = "0.3", features = ["errhandlingapi", "fileapi", "handleapi", "winerror"] }
-
-[target.'cfg(target_os = "redox")'.dependencies]
-termion = "1.5"
+winapi-util = { version= "0.1.5", optional=true }
 
 [features]
 default = []
 # * non-default features
 encoding = ["data-encoding", "data-encoding-macro", "z85", "thiserror"]
 entries = ["libc"]
-fs = ["libc"]
+fs = ["libc", "nix", "winapi-util"]
 fsext = ["libc", "time"]
+lines = []
+memo = ["itertools"]
 mode = ["libc"]
 perms = ["libc", "walkdir"]
 process = ["libc"]
diff --git a/src/uucore/LICENSE b/src/uucore/LICENSE
new file mode 120000
index 000000000..30cff7403
--- /dev/null
+++ b/src/uucore/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
\ No newline at end of file
diff --git a/src/uucore/src/lib/features.rs b/src/uucore/src/lib/features.rs
index 546cbea87..b1b87a613 100644
--- a/src/uucore/src/lib/features.rs
+++ b/src/uucore/src/lib/features.rs
@@ -6,8 +6,14 @@ pub mod encoding;
 pub mod fs;
 #[cfg(feature = "fsext")]
 pub mod fsext;
+#[cfg(feature = "lines")]
+pub mod lines;
+#[cfg(feature = "memo")]
+pub mod memo;
 #[cfg(feature = "ringbuffer")]
 pub mod ringbuffer;
+#[cfg(feature = "memo")]
+mod tokenize;
 
 // * (platform-specific) feature-gated modules
 // ** non-windows (i.e. Unix + Fuchsia)
diff --git a/src/uucore/src/lib/features/encoding.rs b/src/uucore/src/lib/features/encoding.rs
index 100866609..e99017070 100644
--- a/src/uucore/src/lib/features/encoding.rs
+++ b/src/uucore/src/lib/features/encoding.rs
@@ -107,7 +107,7 @@ pub struct Data<R: Read> {
 
 impl<R: Read> Data<R> {
     pub fn new(input: R, format: Format) -> Self {
-        Data {
+        Self {
             line_wrap: 76,
             ignore_garbage: false,
             input,
@@ -125,11 +125,13 @@ impl<R: Read> Data<R> {
         }
     }
 
+    #[must_use]
     pub fn line_wrap(mut self, wrap: usize) -> Self {
         self.line_wrap = wrap;
         self
     }
 
+    #[must_use]
     pub fn ignore_garbage(mut self, ignore: bool) -> Self {
         self.ignore_garbage = ignore;
         self
@@ -154,12 +156,12 @@ impl<R: Read> Data<R> {
 }
 
 // NOTE: this will likely be phased out at some point
-pub fn wrap_print<R: Read>(data: &Data<R>, res: String) {
+pub fn wrap_print<R: Read>(data: &Data<R>, res: &str) {
     let stdout = io::stdout();
     wrap_write(stdout.lock(), data.line_wrap, res).unwrap();
 }
 
-pub fn wrap_write<W: Write>(mut writer: W, line_wrap: usize, res: String) -> io::Result<()> {
+pub fn wrap_write<W: Write>(mut writer: W, line_wrap: usize, res: &str) -> io::Result<()> {
     use std::cmp::min;
 
     if line_wrap == 0 {
diff --git a/src/uucore/src/lib/features/entries.rs b/src/uucore/src/lib/features/entries.rs
index f139d6871..90f3134ab 100644
--- a/src/uucore/src/lib/features/entries.rs
+++ b/src/uucore/src/lib/features/entries.rs
@@ -41,15 +41,18 @@ use libc::{c_char, c_int, gid_t, uid_t};
 use libc::{getgrgid, getgrnam, getgroups};
 use libc::{getpwnam, getpwuid, group, passwd};
 
-use std::borrow::Cow;
+use std::convert::TryInto;
 use std::ffi::{CStr, CString};
 use std::io::Error as IOError;
 use std::io::ErrorKind;
 use std::io::Result as IOResult;
 use std::ptr;
+use std::sync::Mutex;
+
+use once_cell::sync::Lazy;
 
 extern "C" {
-    /// From: https://man7.org/linux/man-pages/man3/getgrouplist.3.html
+    /// From: `<https://man7.org/linux/man-pages/man3/getgrouplist.3.html>`
     /// > The getgrouplist() function scans the group database to obtain
     /// > the list of groups that user belongs to.
     fn getgrouplist(
@@ -60,7 +63,7 @@ extern "C" {
     ) -> c_int;
 }
 
-/// From: https://man7.org/linux/man-pages/man2/getgroups.2.html
+/// From: `<https://man7.org/linux/man-pages/man2/getgroups.2.html>`
 /// > getgroups() returns the supplementary group IDs of the calling
 /// > process in list.
 /// > If size is zero, list is not modified, but the total number of
@@ -69,19 +72,31 @@ extern "C" {
 /// > to be used in a further call to getgroups().
 #[cfg(not(target_os = "redox"))]
 pub fn get_groups() -> IOResult<Vec<gid_t>> {
-    let ngroups = unsafe { getgroups(0, ptr::null_mut()) };
-    if ngroups == -1 {
-        return Err(IOError::last_os_error());
-    }
-    let mut groups = Vec::with_capacity(ngroups as usize);
-    let ngroups = unsafe { getgroups(ngroups, groups.as_mut_ptr()) };
-    if ngroups == -1 {
-        Err(IOError::last_os_error())
-    } else {
-        unsafe {
-            groups.set_len(ngroups as usize);
+    let mut groups = Vec::new();
+    loop {
+        let ngroups = match unsafe { getgroups(0, ptr::null_mut()) } {
+            -1 => return Err(IOError::last_os_error()),
+            // Not just optimization; 0 would mess up the next call
+            0 => return Ok(Vec::new()),
+            n => n,
+        };
+
+        // This is a small buffer, so we can afford to zero-initialize it and
+        // use safe Vec operations
+        groups.resize(ngroups.try_into().unwrap(), 0);
+        let res = unsafe { getgroups(ngroups, groups.as_mut_ptr()) };
+        if res == -1 {
+            let err = IOError::last_os_error();
+            if err.raw_os_error() == Some(libc::EINVAL) {
+                // Number of groups changed, retry
+                continue;
+            } else {
+                return Err(err);
+            }
+        } else {
+            groups.truncate(ngroups.try_into().unwrap());
+            return Ok(groups);
         }
-        Ok(groups)
     }
 }
 
@@ -95,7 +110,7 @@ pub fn get_groups() -> IOResult<Vec<gid_t>> {
 /// to the first entry in the returned Vector. This might be necessary
 /// for `id --groups --real` if `gid` and `egid` are not equal.
 ///
-/// From: https://www.man7.org/linux/man-pages/man3/getgroups.3p.html
+/// From: `<https://www.man7.org/linux/man-pages/man3/getgroups.3p.html>`
 /// > As implied by the definition of supplementary groups, the
 /// > effective group ID may appear in the array returned by
 /// > getgroups() or it may be returned only by getegid().  Duplication
@@ -124,82 +139,62 @@ fn sort_groups(mut groups: Vec<gid_t>, egid: gid_t) -> Vec<gid_t> {
     groups
 }
 
-#[derive(Copy, Clone)]
+#[derive(Clone, Debug)]
 pub struct Passwd {
-    inner: passwd,
+    /// AKA passwd.pw_name
+    pub name: String,
+    /// AKA passwd.pw_uid
+    pub uid: uid_t,
+    /// AKA passwd.pw_gid
+    pub gid: gid_t,
+    /// AKA passwd.pw_gecos
+    pub user_info: String,
+    /// AKA passwd.pw_shell
+    pub user_shell: String,
+    /// AKA passwd.pw_dir
+    pub user_dir: String,
+    /// AKA passwd.pw_passwd
+    pub user_passwd: String,
+    /// AKA passwd.pw_class
+    #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+    pub user_access_class: String,
+    /// AKA passwd.pw_change
+    #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+    pub passwd_change_time: time_t,
+    /// AKA passwd.pw_expire
+    #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+    pub expiration: time_t,
 }
 
-macro_rules! cstr2cow {
-    ($v:expr) => {
-        unsafe { CStr::from_ptr($v).to_string_lossy() }
-    };
+/// SAFETY: ptr must point to a valid C string.
+unsafe fn cstr2string(ptr: *const c_char) -> String {
+    CStr::from_ptr(ptr).to_string_lossy().into_owned()
 }
 
 impl Passwd {
-    /// AKA passwd.pw_name
-    pub fn name(&self) -> Cow<str> {
-        cstr2cow!(self.inner.pw_name)
-    }
-
-    /// AKA passwd.pw_uid
-    pub fn uid(&self) -> uid_t {
-        self.inner.pw_uid
-    }
-
-    /// AKA passwd.pw_gid
-    pub fn gid(&self) -> gid_t {
-        self.inner.pw_gid
-    }
-
-    /// AKA passwd.pw_gecos
-    pub fn user_info(&self) -> Cow<str> {
-        cstr2cow!(self.inner.pw_gecos)
-    }
-
-    /// AKA passwd.pw_shell
-    pub fn user_shell(&self) -> Cow<str> {
-        cstr2cow!(self.inner.pw_shell)
-    }
-
-    /// AKA passwd.pw_dir
-    pub fn user_dir(&self) -> Cow<str> {
-        cstr2cow!(self.inner.pw_dir)
-    }
-
-    /// AKA passwd.pw_passwd
-    pub fn user_passwd(&self) -> Cow<str> {
-        cstr2cow!(self.inner.pw_passwd)
-    }
-
-    /// AKA passwd.pw_class
-    #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
-    pub fn user_access_class(&self) -> Cow<str> {
-        cstr2cow!(self.inner.pw_class)
-    }
-
-    /// AKA passwd.pw_change
-    #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
-    pub fn passwd_change_time(&self) -> time_t {
-        self.inner.pw_change
-    }
-
-    /// AKA passwd.pw_expire
-    #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
-    pub fn expiration(&self) -> time_t {
-        self.inner.pw_expire
-    }
-
-    pub fn as_inner(&self) -> &passwd {
-        &self.inner
-    }
-
-    pub fn into_inner(self) -> passwd {
-        self.inner
+    /// SAFETY: All the pointed-to strings must be valid and not change while
+    /// the function runs. That means PW_LOCK must be held.
+    unsafe fn from_raw(raw: passwd) -> Self {
+        Self {
+            name: cstr2string(raw.pw_name),
+            uid: raw.pw_uid,
+            gid: raw.pw_gid,
+            user_info: cstr2string(raw.pw_gecos),
+            user_shell: cstr2string(raw.pw_shell),
+            user_dir: cstr2string(raw.pw_dir),
+            user_passwd: cstr2string(raw.pw_passwd),
+            #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+            user_access_class: cstr2string(raw.pw_class),
+            #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+            passwd_change_time: raw.pw_change,
+            #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+            expiration: raw.pw_expire,
+        }
     }
 
     /// This is a wrapper function for `libc::getgrouplist`.
     ///
-    /// From: https://man7.org/linux/man-pages/man3/getgrouplist.3.html
+    /// From: `<https://man7.org/linux/man-pages/man3/getgrouplist.3.html>`
     /// > If the number of groups of which user is a member is less than or
     /// > equal to *ngroups, then the value *ngroups is returned.
     /// > If the user is a member of more than *ngroups groups, then
@@ -214,49 +209,44 @@ impl Passwd {
     pub fn belongs_to(&self) -> Vec<gid_t> {
         let mut ngroups: c_int = 8;
         let mut ngroups_old: c_int;
-        let mut groups = Vec::with_capacity(ngroups as usize);
-        let gid = self.inner.pw_gid;
-        let name = self.inner.pw_name;
+        let mut groups = vec![0; ngroups.try_into().unwrap()];
+        let name = CString::new(self.name.clone()).unwrap();
         loop {
             ngroups_old = ngroups;
-            if unsafe { getgrouplist(name, gid, groups.as_mut_ptr(), &mut ngroups) } == -1 {
+            if unsafe { getgrouplist(name.as_ptr(), self.gid, groups.as_mut_ptr(), &mut ngroups) }
+                == -1
+            {
                 if ngroups == ngroups_old {
                     ngroups *= 2;
                 }
-                groups.resize(ngroups as usize, 0);
+                groups.resize(ngroups.try_into().unwrap(), 0);
             } else {
                 break;
             }
         }
-        unsafe {
-            groups.set_len(ngroups as usize);
-        }
-        groups.truncate(ngroups as usize);
+        let ngroups = ngroups.try_into().unwrap();
+        assert!(ngroups <= groups.len());
+        groups.truncate(ngroups);
         groups
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct Group {
-    inner: group,
+    /// AKA group.gr_name
+    pub name: String,
+    /// AKA group.gr_gid
+    pub gid: gid_t,
 }
 
 impl Group {
-    /// AKA group.gr_name
-    pub fn name(&self) -> Cow<str> {
-        cstr2cow!(self.inner.gr_name)
-    }
-
-    /// AKA group.gr_gid
-    pub fn gid(&self) -> gid_t {
-        self.inner.gr_gid
-    }
-
-    pub fn as_inner(&self) -> &group {
-        &self.inner
-    }
-
-    pub fn into_inner(self) -> group {
-        self.inner
+    /// SAFETY: gr_name must be valid and not change while
+    /// the function runs. That means PW_LOCK must be held.
+    unsafe fn from_raw(raw: group) -> Self {
+        Self {
+            name: cstr2string(raw.gr_name),
+            gid: raw.gr_gid,
+        }
     }
 }
 
@@ -267,17 +257,32 @@ pub trait Locate<K> {
         Self: ::std::marker::Sized;
 }
 
+// These functions are not thread-safe:
+// > The return value may point to a static area, and may be
+// > overwritten by subsequent calls to getpwent(3), getpwnam(),
+// > or getpwuid().
+// This applies not just to the struct but also the strings it points
+// to, so we must copy all the data we want before releasing the lock.
+// (Technically we must also ensure that the raw functions aren't being called
+// anywhere else in the program.)
+static PW_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+
 macro_rules! f {
     ($fnam:ident, $fid:ident, $t:ident, $st:ident) => {
         impl Locate<$t> for $st {
             fn locate(k: $t) -> IOResult<Self> {
+                let _guard = PW_LOCK.lock();
+                // SAFETY: We're holding PW_LOCK.
                 unsafe {
                     let data = $fid(k);
                     if !data.is_null() {
-                        Ok($st {
-                            inner: ptr::read(data as *const _),
-                        })
+                        Ok($st::from_raw(ptr::read(data as *const _)))
                     } else {
+                        // FIXME: Resource limits, signals and I/O failure may
+                        // cause this too. See getpwnam(3).
+                        // errno must be set to zero before the call. We can
+                        // use libc::__errno_location() on some platforms.
+                        // The same applies for the two cases below.
                         Err(IOError::new(
                             ErrorKind::NotFound,
                             format!("No such id: {}", k),
@@ -289,25 +294,26 @@ macro_rules! f {
 
         impl<'a> Locate<&'a str> for $st {
             fn locate(k: &'a str) -> IOResult<Self> {
+                let _guard = PW_LOCK.lock();
                 if let Ok(id) = k.parse::<$t>() {
-                    let data = unsafe { $fid(id) };
-                    if !data.is_null() {
-                        Ok($st {
-                            inner: unsafe { ptr::read(data as *const _) },
-                        })
-                    } else {
-                        Err(IOError::new(
-                            ErrorKind::NotFound,
-                            format!("No such id: {}", id),
-                        ))
+                    // SAFETY: We're holding PW_LOCK.
+                    unsafe {
+                        let data = $fid(id);
+                        if !data.is_null() {
+                            Ok($st::from_raw(ptr::read(data as *const _)))
+                        } else {
+                            Err(IOError::new(
+                                ErrorKind::NotFound,
+                                format!("No such id: {}", id),
+                            ))
+                        }
                     }
                 } else {
+                    // SAFETY: We're holding PW_LOCK.
                     unsafe {
                         let data = $fnam(CString::new(k).unwrap().as_ptr());
                         if !data.is_null() {
-                            Ok($st {
-                                inner: ptr::read(data as *const _),
-                            })
+                            Ok($st::from_raw(ptr::read(data as *const _)))
                         } else {
                             Err(IOError::new(
                                 ErrorKind::NotFound,
@@ -327,24 +333,24 @@ f!(getgrnam, getgrgid, gid_t, Group);
 
 #[inline]
 pub fn uid2usr(id: uid_t) -> IOResult<String> {
-    Passwd::locate(id).map(|p| p.name().into_owned())
+    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().into_owned())
+    Group::locate(id).map(|p| p.name)
 }
 
 #[inline]
 pub fn usr2uid(name: &str) -> IOResult<uid_t> {
-    Passwd::locate(name).map(|p| p.uid())
+    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())
+    Group::locate(name).map(|p| p.gid)
 }
 
 #[cfg(test)]
diff --git a/src/uucore/src/lib/features/fs.rs b/src/uucore/src/lib/features/fs.rs
index 0b8079a5c..5cd6d253d 100644
--- a/src/uucore/src/lib/features/fs.rs
+++ b/src/uucore/src/lib/features/fs.rs
@@ -17,12 +17,15 @@ use libc::{
 use std::borrow::Cow;
 use std::env;
 use std::fs;
+use std::hash::Hash;
 use std::io::Error as IOError;
 use std::io::Result as IOResult;
 use std::io::{Error, ErrorKind};
-#[cfg(any(unix, target_os = "redox"))]
-use std::os::unix::fs::MetadataExt;
+#[cfg(unix)]
+use std::os::unix::{fs::MetadataExt, io::AsRawFd};
 use std::path::{Component, Path, PathBuf};
+#[cfg(target_os = "windows")]
+use winapi_util::AsHandleRef;
 
 #[cfg(unix)]
 #[macro_export]
@@ -32,6 +35,114 @@ macro_rules! has {
     };
 }
 
+/// Information to uniquely identify a file
+pub struct FileInformation(
+    #[cfg(unix)] nix::sys::stat::FileStat,
+    #[cfg(windows)] winapi_util::file::Information,
+);
+
+impl FileInformation {
+    /// Get information from a currently open file
+    #[cfg(unix)]
+    pub fn from_file(file: &impl AsRawFd) -> Option<Self> {
+        if let Ok(x) = nix::sys::stat::fstat(file.as_raw_fd()) {
+            Some(Self(x))
+        } else {
+            None
+        }
+    }
+
+    /// Get information from a currently open file
+    #[cfg(target_os = "windows")]
+    pub fn from_file(file: &impl AsHandleRef) -> Option<Self> {
+        if let Ok(x) = winapi_util::file::information(file.as_handle_ref()) {
+            Some(Self(x))
+        } else {
+            None
+        }
+    }
+
+    /// Get information for a given path.
+    ///
+    /// If `path` points to a symlink and `dereference` is true, information about
+    /// the link's target will be returned.
+    pub fn from_path(path: impl AsRef<Path>, dereference: bool) -> Option<Self> {
+        #[cfg(unix)]
+        {
+            let stat = if dereference {
+                nix::sys::stat::stat(path.as_ref())
+            } else {
+                nix::sys::stat::lstat(path.as_ref())
+            };
+            if let Ok(stat) = stat {
+                Some(Self(stat))
+            } else {
+                None
+            }
+        }
+        #[cfg(target_os = "windows")]
+        {
+            use std::fs::OpenOptions;
+            use std::os::windows::prelude::*;
+            let mut open_options = OpenOptions::new();
+            if !dereference {
+                open_options.custom_flags(winapi::um::winbase::FILE_FLAG_OPEN_REPARSE_POINT);
+            }
+            open_options
+                .read(true)
+                .open(path.as_ref())
+                .ok()
+                .and_then(|file| Self::from_file(&file))
+        }
+    }
+
+    pub fn file_size(&self) -> u64 {
+        #[cfg(unix)]
+        {
+            use std::convert::TryInto;
+
+            assert!(self.0.st_size >= 0, "File size is negative");
+            self.0.st_size.try_into().unwrap()
+        }
+        #[cfg(target_os = "windows")]
+        {
+            self.0.file_size()
+        }
+    }
+}
+
+#[cfg(unix)]
+impl PartialEq for FileInformation {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.st_dev == other.0.st_dev && self.0.st_ino == other.0.st_ino
+    }
+}
+
+#[cfg(target_os = "windows")]
+impl PartialEq for FileInformation {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.volume_serial_number() == other.0.volume_serial_number()
+            && self.0.file_index() == other.0.file_index()
+    }
+}
+
+impl Eq for FileInformation {}
+
+impl Hash for FileInformation {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        #[cfg(unix)]
+        {
+            self.0.st_dev.hash(state);
+            self.0.st_ino.hash(state);
+        }
+        #[cfg(target_os = "windows")]
+        {
+            self.0.volume_serial_number().hash(state);
+            self.0.file_index().hash(state);
+        }
+    }
+}
+
 pub fn resolve_relative_path(path: &Path) -> Cow<Path> {
     if path.components().all(|e| e != Component::ParentDir) {
         return path.into();
@@ -48,7 +159,7 @@ pub fn resolve_relative_path(path: &Path) -> Cow<Path> {
             }
             Component::CurDir => (),
             Component::RootDir | Component::Normal(_) | Component::Prefix(_) => {
-                result.push(comp.as_os_str())
+                result.push(comp.as_os_str());
             }
         }
     }
@@ -112,15 +223,17 @@ pub fn normalize_path(path: &Path) -> PathBuf {
     ret
 }
 
-fn resolve<P: AsRef<Path>>(original: P) -> Result<PathBuf, (PathBuf, IOError)> {
+fn resolve<P: AsRef<Path>>(original: P) -> Result<PathBuf, (bool, PathBuf, IOError)> {
     const MAX_LINKS_FOLLOWED: u32 = 255;
     let mut followed = 0;
     let mut result = original.as_ref().to_path_buf();
-
+    let mut symlink_is_absolute = false;
     let mut first_resolution = None;
+
     loop {
         if followed == MAX_LINKS_FOLLOWED {
             return Err((
+                symlink_is_absolute,
                 // When we hit MAX_LINKS_FOLLOWED we should return the first resolution (that's what GNU does - for whatever reason)
                 first_resolution.unwrap(),
                 Error::new(ErrorKind::InvalidInput, "maximum links followed"),
@@ -133,16 +246,17 @@ fn resolve<P: AsRef<Path>>(original: P) -> Result<PathBuf, (PathBuf, IOError)> {
                     break;
                 }
             }
-            Err(e) => return Err((result, e)),
+            Err(e) => return Err((symlink_is_absolute, result, e)),
         }
 
         followed += 1;
         match fs::read_link(&result) {
             Ok(path) => {
                 result.pop();
+                symlink_is_absolute = path.is_absolute();
                 result.push(path);
             }
-            Err(e) => return Err((result, e)),
+            Err(e) => return Err((symlink_is_absolute, result, e)),
         }
 
         if first_resolution.is_none() {
@@ -188,9 +302,8 @@ pub fn canonicalize<P: AsRef<Path>>(
     let original = if original.is_absolute() {
         original.to_path_buf()
     } else {
-        dunce::canonicalize(env::current_dir().unwrap())
-            .unwrap()
-            .join(original)
+        let current_dir = env::current_dir()?;
+        dunce::canonicalize(current_dir)?.join(original)
     };
 
     let mut result = PathBuf::new();
@@ -233,8 +346,13 @@ pub fn canonicalize<P: AsRef<Path>>(
             }
 
             match resolve(&result) {
-                Err((path, _)) if miss_mode == MissingHandling::Missing => result = path,
-                Err((_, e)) => return Err(e),
+                Err((_, path, e)) => {
+                    if miss_mode == MissingHandling::Missing {
+                        result = path;
+                    } else {
+                        return Err(e);
+                    }
+                }
                 Ok(path) => {
                     result = path;
                 }
@@ -248,10 +366,20 @@ pub fn canonicalize<P: AsRef<Path>>(
         }
 
         match resolve(&result) {
-            Err((_, e)) if miss_mode == MissingHandling::Existing => {
-                return Err(e);
+            Err((is_absolute, path, err)) => {
+                // If the resolved symlink is an absolute path and non-existent,
+                // `realpath` throws no such file error.
+                if miss_mode == MissingHandling::Existing
+                    || (err.kind() == ErrorKind::NotFound
+                        && is_absolute
+                        && miss_mode == MissingHandling::Normal)
+                {
+                    return Err(err);
+                } else {
+                    result = path;
+                }
             }
-            Ok(path) | Err((path, _)) => {
+            Ok(path) => {
                 result = path;
             }
         }
@@ -342,6 +470,20 @@ pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String
     result
 }
 
+// For some programs like install or mkdir, dir/. can be provided
+// Special case to match GNU's behavior:
+// install -d foo/. should work and just create foo/
+// std::fs::create_dir("foo/."); fails in pure Rust
+// See also mkdir.rs for another occurrence of this
+pub fn dir_strip_dot_for_creation(path: &Path) -> PathBuf {
+    if path.to_string_lossy().ends_with("/.") {
+        // Do a simple dance to strip the "/."
+        Path::new(&path).components().collect::<PathBuf>()
+    } else {
+        path.to_path_buf()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
@@ -389,12 +531,12 @@ mod tests {
 
     #[test]
     fn test_normalize_path() {
-        for test in NORMALIZE_PATH_TESTS.iter() {
+        for test in &NORMALIZE_PATH_TESTS {
             let path = Path::new(test.path);
             let normalized = normalize_path(path);
             assert_eq!(
                 test.test
-                    .replace("/", std::path::MAIN_SEPARATOR.to_string().as_str()),
+                    .replace('/', std::path::MAIN_SEPARATOR.to_string().as_str()),
                 normalized.to_str().expect("Path is not valid utf-8!")
             );
         }
diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs
index 97c1da79c..6845ca3ca 100644
--- a/src/uucore/src/lib/features/fsext.rs
+++ b/src/uucore/src/lib/features/fsext.rs
@@ -70,7 +70,15 @@ use libc::{
 };
 use std::borrow::Cow;
 use std::convert::{AsRef, From};
-#[cfg(unix)]
+#[cfg(any(
+    target_vendor = "apple",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "linux"
+))]
+use std::ffi::CStr;
+#[cfg(not(windows))]
 use std::ffi::CString;
 use std::io::Error as IOError;
 #[cfg(unix)]
@@ -90,6 +98,8 @@ pub use libc::statfs as StatFs;
     target_os = "netbsd",
     target_os = "bitrig",
     target_os = "dragonfly",
+    target_os = "illumos",
+    target_os = "solaris",
     target_os = "redox"
 ))]
 pub use libc::statvfs as StatFs;
@@ -100,13 +110,15 @@ pub use libc::statvfs as StatFs;
     target_os = "android",
     target_os = "freebsd",
     target_os = "openbsd",
+    target_os = "redox"
 ))]
 pub use libc::statfs as statfs_fn;
 #[cfg(any(
     target_os = "netbsd",
     target_os = "bitrig",
-    target_os = "dragonfly",
-    target_os = "redox"
+    target_os = "illumos",
+    target_os = "solaris",
+    target_os = "dragonfly"
 ))]
 pub use libc::statvfs as statfs_fn;
 
@@ -156,7 +168,7 @@ impl MountInfo {
             // 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()
+                self.dev_id = (stat.dev() as i32).to_string();
             } else {
                 self.dev_id = "".to_string();
             }
@@ -197,16 +209,20 @@ impl MountInfo {
     }
 
     #[cfg(target_os = "linux")]
-    fn new(file_name: &str, raw: Vec<&str>) -> Option<MountInfo> {
+    fn new(file_name: &str, raw: &[&str]) -> Option<Self> {
         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
             // "man proc" for more details
             LINUX_MOUNTINFO => {
-                let mut m = MountInfo {
+                const FIELDS_OFFSET: usize = 6;
+                let after_fields = raw[FIELDS_OFFSET..].iter().position(|c| *c == "-").unwrap()
+                    + FIELDS_OFFSET
+                    + 1;
+                let mut m = Self {
                     dev_id: "".to_string(),
-                    dev_name: raw[9].to_string(),
-                    fs_type: raw[8].to_string(),
+                    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(),
@@ -217,7 +233,7 @@ impl MountInfo {
                 Some(m)
             }
             LINUX_MTAB => {
-                let mut m = MountInfo {
+                let mut m = Self {
                     dev_id: "".to_string(),
                     dev_name: raw[0].to_string(),
                     fs_type: raw[2].to_string(),
@@ -234,7 +250,7 @@ impl MountInfo {
         }
     }
     #[cfg(windows)]
-    fn new(mut volume_name: String) -> Option<MountInfo> {
+    fn new(mut volume_name: String) -> Option<Self> {
         let mut dev_name_buf = [0u16; MAX_PATH];
         volume_name.pop();
         unsafe {
@@ -285,7 +301,7 @@ impl MountInfo {
         } else {
             None
         };
-        let mut mn_info = MountInfo {
+        let mut mn_info = Self {
             dev_id: volume_name,
             dev_name,
             fs_type: fs_type.unwrap_or_else(|| "".to_string()),
@@ -300,13 +316,6 @@ impl MountInfo {
     }
 }
 
-#[cfg(any(
-    target_vendor = "apple",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd"
-))]
-use std::ffi::CStr;
 #[cfg(any(
     target_os = "freebsd",
     target_vendor = "apple",
@@ -315,7 +324,7 @@ use std::ffi::CStr;
 ))]
 impl From<StatFs> for MountInfo {
     fn from(statfs: StatFs) -> Self {
-        let mut info = MountInfo {
+        let mut info = Self {
             dev_id: "".to_string(),
             dev_name: unsafe {
                 // spell-checker:disable-next-line
@@ -406,7 +415,7 @@ pub fn read_fs_list() -> Vec<MountInfo> {
             .filter_map(|line| line.ok())
             .filter_map(|line| {
                 let raw_data = line.split_whitespace().collect::<Vec<&str>>();
-                MountInfo::new(file_name, raw_data)
+                MountInfo::new(file_name, &raw_data)
             })
             .collect::<Vec<_>>()
     }
@@ -472,7 +481,7 @@ pub fn read_fs_list() -> Vec<MountInfo> {
         }
         mounts
     }
-    #[cfg(target_os = "redox")]
+    #[cfg(any(target_os = "redox", target_os = "illumos", target_os = "solaris"))]
     {
         // No method to read mounts, yet
         Vec::new()
@@ -492,9 +501,9 @@ pub struct FsUsage {
 
 impl FsUsage {
     #[cfg(unix)]
-    pub fn new(statvfs: StatFs) -> FsUsage {
+    pub fn new(statvfs: StatFs) -> Self {
         {
-            FsUsage {
+            Self {
                 blocksize: statvfs.f_bsize as u64, // or `statvfs.f_frsize` ?
                 blocks: statvfs.f_blocks as u64,
                 bfree: statvfs.f_bfree as u64,
@@ -506,7 +515,7 @@ impl FsUsage {
         }
     }
     #[cfg(not(unix))]
-    pub fn new(path: &Path) -> FsUsage {
+    pub fn new(path: &Path) -> Self {
         let mut root_path = [0u16; MAX_PATH];
         let success = unsafe {
             GetVolumePathNamesForVolumeNameW(
@@ -549,7 +558,7 @@ impl FsUsage {
         }
 
         let bytes_per_cluster = sectors_per_cluster as u64 * bytes_per_sector as u64;
-        FsUsage {
+        Self {
             // f_bsize      File system block size.
             blocksize: bytes_per_cluster as u64,
             // f_blocks - Total number of blocks on the file system, in units of f_frsize.
@@ -563,7 +572,7 @@ impl FsUsage {
             // Total number of file nodes (inodes) on the file system.
             files: 0, // Not available on windows
             // Total number of free file nodes (inodes).
-            ffree: 4096, // Meaningless on Windows
+            ffree: 0, // Meaningless on Windows
         }
     }
 }
@@ -696,9 +705,10 @@ where
                     0 => Ok(buffer),
                     _ => {
                         let errno = IOError::last_os_error().raw_os_error().unwrap_or(0);
-                        Err(CString::from_raw(strerror(errno))
-                            .into_string()
-                            .unwrap_or_else(|_| "Unknown Error".to_owned()))
+                        Err(CStr::from_ptr(strerror(errno))
+                            .to_str()
+                            .map_err(|_| "Error message contains invalid UTF-8".to_owned())?
+                            .to_owned())
                     }
                 }
             }
@@ -891,4 +901,46 @@ mod tests {
         assert_eq!("UNKNOWN (0x1234)", pretty_fstype(0x1234));
         // spell-checker:enable
     }
+
+    #[test]
+    #[cfg(target_os = "linux")]
+    fn test_mountinfo() {
+        // spell-checker:ignore (word) relatime
+        let info = MountInfo::new(
+            LINUX_MOUNTINFO,
+            &"106 109 253:6 / /mnt rw,relatime - xfs /dev/fs0 rw"
+                .split_ascii_whitespace()
+                .collect::<Vec<_>>(),
+        )
+        .unwrap();
+
+        assert_eq!(info.mount_root, "/");
+        assert_eq!(info.mount_dir, "/mnt");
+        assert_eq!(info.mount_option, "rw,relatime");
+        assert_eq!(info.fs_type, "xfs");
+        assert_eq!(info.dev_name, "/dev/fs0");
+
+        // Test parsing with different amounts of optional fields.
+        let info = MountInfo::new(
+            LINUX_MOUNTINFO,
+            &"106 109 253:6 / /mnt rw,relatime master:1 - xfs /dev/fs0 rw"
+                .split_ascii_whitespace()
+                .collect::<Vec<_>>(),
+        )
+        .unwrap();
+
+        assert_eq!(info.fs_type, "xfs");
+        assert_eq!(info.dev_name, "/dev/fs0");
+
+        let info = MountInfo::new(
+            LINUX_MOUNTINFO,
+            &"106 109 253:6 / /mnt rw,relatime master:1 shared:2 - xfs /dev/fs0 rw"
+                .split_ascii_whitespace()
+                .collect::<Vec<_>>(),
+        )
+        .unwrap();
+
+        assert_eq!(info.fs_type, "xfs");
+        assert_eq!(info.dev_name, "/dev/fs0");
+    }
 }
diff --git a/src/uucore/src/lib/features/lines.rs b/src/uucore/src/lib/features/lines.rs
new file mode 100644
index 000000000..a7f4df76d
--- /dev/null
+++ b/src/uucore/src/lib/features/lines.rs
@@ -0,0 +1,113 @@
+//  * 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)
+//! Iterate over lines, including the line ending character(s).
+//!
+//! This module provides the [`lines`] function, similar to the
+//! [`BufRead::lines`] method. While the [`BufRead::lines`] method
+//! yields [`String`] instances that do not include the line ending
+//! characters (`"\n"` or `"\r\n"`), our functions yield
+//! [`Vec`]<['u8']> instances that include the line ending
+//! characters. This is useful if the input data does not end with a
+//! newline character and you want to preserve the exact form of the
+//! input data.
+use std::io::BufRead;
+
+/// Returns an iterator over the lines, including line ending characters.
+///
+/// This function is just like [`BufRead::lines`], but it includes the
+/// line ending characters in each yielded [`String`] if the input
+/// data has them. Set the `sep` parameter to the line ending
+/// character; for Unix line endings, use `b'\n'`.
+///
+/// # Examples
+///
+/// Use `sep` to specify an alternate character for line endings. For
+/// example, if lines are terminated by the null character `b'\0'`:
+///
+/// ```rust,ignore
+/// use std::io::BufRead;
+/// use std::io::Cursor;
+///
+/// let cursor = Cursor::new(b"x\0y\0z\0");
+/// let mut it = lines(cursor, b'\0').map(|l| l.unwrap());
+///
+/// assert_eq!(it.next(), Some(Vec::from("x\0")));
+/// assert_eq!(it.next(), Some(Vec::from("y\0")));
+/// assert_eq!(it.next(), Some(Vec::from("z\0")));
+/// assert_eq!(it.next(), None);
+/// ```
+///
+/// If the input data does not end with a newline character (`'\n'`),
+/// then the last [`String`] yielded by this iterator also does not
+/// end with a newline:
+///
+/// ```rust,ignore
+/// let cursor = Cursor::new(b"x\ny\nz");
+/// let mut it = lines(cursor, b'\n').map(|l| l.unwrap());
+///
+/// assert_eq!(it.next(), Some(Vec::from("x\n")));
+/// assert_eq!(it.next(), Some(Vec::from("y\n")));
+/// assert_eq!(it.next(), Some(Vec::from("z")));
+/// assert_eq!(it.next(), None);
+/// ```
+pub fn lines<B>(reader: B, sep: u8) -> Lines<B>
+where
+    B: BufRead,
+{
+    Lines { buf: reader, sep }
+}
+
+/// An iterator over the lines of an instance of `BufRead`.
+///
+/// This struct is generally created by calling [`lines`] on a `BufRead`.
+/// Please see the documentation of [`lines`] for more details.
+pub struct Lines<B> {
+    buf: B,
+    sep: u8,
+}
+
+impl<B: BufRead> Iterator for Lines<B> {
+    type Item = std::io::Result<Vec<u8>>;
+
+    fn next(&mut self) -> Option<std::io::Result<Vec<u8>>> {
+        let mut buf = Vec::new();
+        match self.buf.read_until(self.sep, &mut buf) {
+            Ok(0) => None,
+            Ok(_n) => Some(Ok(buf)),
+            Err(e) => Some(Err(e)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::lines::lines;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_lines() {
+        let cursor = Cursor::new(b"x\ny\nz");
+        let mut it = lines(cursor, b'\n').map(|l| l.unwrap());
+
+        assert_eq!(it.next(), Some(Vec::from("x\n")));
+        assert_eq!(it.next(), Some(Vec::from("y\n")));
+        assert_eq!(it.next(), Some(Vec::from("z")));
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn test_lines_zero_terminated() {
+        use std::io::Cursor;
+
+        let cursor = Cursor::new(b"x\0y\0z\0");
+        let mut it = lines(cursor, b'\0').map(|l| l.unwrap());
+
+        assert_eq!(it.next(), Some(Vec::from("x\0")));
+        assert_eq!(it.next(), Some(Vec::from("y\0")));
+        assert_eq!(it.next(), Some(Vec::from("z\0")));
+        assert_eq!(it.next(), None);
+    }
+}
diff --git a/src/uu/printf/src/memo.rs b/src/uucore/src/lib/features/memo.rs
similarity index 76%
rename from src/uu/printf/src/memo.rs
rename to src/uucore/src/lib/features/memo.rs
index a87d4fa89..0e3a6376c 100644
--- a/src/uu/printf/src/memo.rs
+++ b/src/uucore/src/lib/features/memo.rs
@@ -5,15 +5,15 @@
 //! 2. feeds remaining arguments into function
 //! that prints tokens.
 
+use crate::display::Quotable;
+use crate::error::UResult;
+use crate::features::tokenize::sub::Sub;
+use crate::features::tokenize::token::{Token, Tokenizer};
+use crate::features::tokenize::unescaped_text::UnescapedText;
+use crate::show_warning;
 use itertools::put_back_n;
 use std::iter::Peekable;
 use std::slice::Iter;
-use uucore::display::Quotable;
-use uucore::show_warning;
-
-use crate::tokenize::sub::Sub;
-use crate::tokenize::token::{Token, Tokenizer};
-use crate::tokenize::unescaped_text::UnescapedText;
 
 pub struct Memo {
     tokens: Vec<Box<dyn Token>>,
@@ -27,17 +27,17 @@ fn warn_excess_args(first_arg: &str) {
 }
 
 impl Memo {
-    pub fn new(pf_string: &str, pf_args_it: &mut Peekable<Iter<String>>) -> Memo {
-        let mut pm = Memo { tokens: Vec::new() };
+    pub fn new(pf_string: &str, pf_args_it: &mut Peekable<Iter<String>>) -> UResult<Self> {
+        let mut pm = Self { tokens: Vec::new() };
         let mut tmp_token: Option<Box<dyn Token>>;
         let mut it = put_back_n(pf_string.chars());
         let mut has_sub = false;
         loop {
-            tmp_token = UnescapedText::from_it(&mut it, pf_args_it);
+            tmp_token = UnescapedText::from_it(&mut it, pf_args_it)?;
             if let Some(x) = tmp_token {
                 pm.tokens.push(x);
             }
-            tmp_token = Sub::from_it(&mut it, pf_args_it);
+            tmp_token = Sub::from_it(&mut it, pf_args_it)?;
             if let Some(x) = tmp_token {
                 if !has_sub {
                     has_sub = true;
@@ -65,19 +65,19 @@ impl Memo {
                 }
             }
         }
-        pm
+        Ok(pm)
     }
     pub fn apply(&self, pf_args_it: &mut Peekable<Iter<String>>) {
-        for tkn in self.tokens.iter() {
+        for tkn in &self.tokens {
             tkn.print(pf_args_it);
         }
     }
-    pub fn run_all(pf_string: &str, pf_args: &[String]) {
+    pub fn run_all(pf_string: &str, pf_args: &[String]) -> UResult<()> {
         let mut arg_it = pf_args.iter().peekable();
-        let pm = Memo::new(pf_string, &mut arg_it);
+        let pm = Self::new(pf_string, &mut arg_it)?;
         loop {
             if arg_it.peek().is_none() {
-                break;
+                return Ok(());
             }
             pm.apply(&mut arg_it);
         }
diff --git a/src/uucore/src/lib/features/mode.rs b/src/uucore/src/lib/features/mode.rs
index 5e299f988..bf11e481a 100644
--- a/src/uucore/src/lib/features/mode.rs
+++ b/src/uucore/src/lib/features/mode.rs
@@ -62,7 +62,7 @@ pub fn parse_symbolic(
                     // keep the setgid and setuid bits for directories
                     srwx |= fperm & (0o4000 | 0o2000);
                 }
-                fperm = (fperm & !mask) | (srwx & mask)
+                fperm = (fperm & !mask) | (srwx & mask);
             }
             _ => unreachable!(),
         }
@@ -113,7 +113,7 @@ fn parse_change(mode: &str, fperm: u32, considering_dir: bool) -> (u32, usize) {
             'x' => srwx |= 0o111,
             'X' => {
                 if considering_dir || (fperm & 0o0111) != 0 {
-                    srwx |= 0o111
+                    srwx |= 0o111;
                 }
             }
             's' => srwx |= 0o4000 | 0o2000,
@@ -163,12 +163,11 @@ pub fn strip_minus_from_mode(args: &mut Vec<String>) -> bool {
         if arg == "--" {
             break;
         }
-        if arg.starts_with('-') {
+        if let Some(arg_stripped) = arg.strip_prefix('-') {
             if let Some(second) = arg.chars().nth(1) {
                 match second {
                     'r' | 'w' | 'x' | 'X' | 's' | 't' | 'u' | 'g' | 'o' | '0'..='7' => {
-                        // TODO: use strip_prefix() once minimum rust version reaches 1.45.0
-                        *arg = arg[1..arg.len()].to_string();
+                        *arg = arg_stripped.to_string();
                         return true;
                     }
                     _ => {}
diff --git a/src/uucore/src/lib/features/perms.rs b/src/uucore/src/lib/features/perms.rs
index 16ee01b88..d8e345313 100644
--- a/src/uucore/src/lib/features/perms.rs
+++ b/src/uucore/src/lib/features/perms.rs
@@ -12,9 +12,9 @@ use crate::error::USimpleError;
 pub use crate::features::entries;
 use crate::fs::resolve_relative_path;
 use crate::show_error;
-use clap::App;
 use clap::Arg;
 use clap::ArgMatches;
+use clap::Command;
 use libc::{self, gid_t, uid_t};
 use walkdir::WalkDir;
 
@@ -296,9 +296,9 @@ impl ChownExecutor {
                             } else {
                                 "Too many levels of symbolic links".into()
                             }
-                        )
+                        );
                     } else {
-                        show_error!("{}", e)
+                        show_error!("{}", e);
                     }
                     continue;
                 }
@@ -383,6 +383,7 @@ impl ChownExecutor {
 }
 
 pub mod options {
+    pub const HELP: &str = "help";
     pub mod verbosity {
         pub const CHANGES: &str = "changes";
         pub const QUIET: &str = "quiet";
@@ -410,20 +411,20 @@ pub mod options {
     pub const ARG_FILES: &str = "FILE";
 }
 
-type GidUidFilterParser<'a> = fn(&ArgMatches<'a>) -> UResult<(Option<u32>, Option<u32>, IfFrom)>;
+type GidUidFilterParser = fn(&ArgMatches) -> UResult<(Option<u32>, Option<u32>, IfFrom)>;
 
 /// Base implementation for `chgrp` and `chown`.
 ///
-/// An argument called `add_arg_if_not_reference` will be added to `app` if
+/// An argument called `add_arg_if_not_reference` will be added to `command` if
 /// `args` does not contain the `--reference` option.
 /// `parse_gid_uid_and_filter` will be called to obtain the target gid and uid, and the filter,
 /// from `ArgMatches`.
 /// `groups_only` determines whether verbose output will only mention the group.
 pub fn chown_base<'a>(
-    mut app: App<'a, 'a>,
+    mut command: Command<'a>,
     args: impl crate::Args,
     add_arg_if_not_reference: &'a str,
-    parse_gid_uid_and_filter: GidUidFilterParser<'a>,
+    parse_gid_uid_and_filter: GidUidFilterParser,
     groups_only: bool,
 ) -> UResult<()> {
     let args: Vec<_> = args.collect();
@@ -444,23 +445,23 @@ pub fn chown_base<'a>(
     if help || !reference {
         // add both positional arguments
         // arg_group is only required if
-        app = app.arg(
-            Arg::with_name(add_arg_if_not_reference)
+        command = command.arg(
+            Arg::new(add_arg_if_not_reference)
                 .value_name(add_arg_if_not_reference)
                 .required(true)
                 .takes_value(true)
-                .multiple(false),
-        )
+                .multiple_occurrences(false),
+        );
     }
-    app = app.arg(
-        Arg::with_name(options::ARG_FILES)
+    command = command.arg(
+        Arg::new(options::ARG_FILES)
             .value_name(options::ARG_FILES)
-            .multiple(true)
+            .multiple_occurrences(true)
             .takes_value(true)
             .required(true)
             .min_values(1),
     );
-    let matches = app.get_matches_from(args);
+    let matches = command.get_matches_from(args);
 
     let files: Vec<String> = matches
         .values_of(options::ARG_FILES)
diff --git a/src/uucore/src/lib/features/pipes.rs b/src/uucore/src/lib/features/pipes.rs
index b375982dd..87cbe9bf2 100644
--- a/src/uucore/src/lib/features/pipes.rs
+++ b/src/uucore/src/lib/features/pipes.rs
@@ -9,7 +9,7 @@ use nix::{fcntl::SpliceFFlags, sys::uio::IoVec};
 
 pub use nix::{Error, Result};
 
-/// A wrapper around [`nix::unistd::Pipe`] that ensures the pipe is cleaned up.
+/// A wrapper around [`nix::unistd::pipe`] that ensures the pipe is cleaned up.
 ///
 /// Returns two `File` objects: everything written to the second can be read
 /// from the first.
diff --git a/src/uucore/src/lib/features/process.rs b/src/uucore/src/lib/features/process.rs
index d0f530a5a..b573fdfcc 100644
--- a/src/uucore/src/lib/features/process.rs
+++ b/src/uucore/src/lib/features/process.rs
@@ -56,12 +56,12 @@ impl ExitStatus {
             use std::os::unix::process::ExitStatusExt;
 
             if let Some(signal) = status.signal() {
-                return ExitStatus::Signal(signal);
+                return Self::Signal(signal);
             }
         }
 
         // NOTE: this should never fail as we check if the program exited through a signal above
-        ExitStatus::Code(status.code().unwrap())
+        Self::Code(status.code().unwrap())
     }
 
     pub fn success(&self) -> bool {
diff --git a/src/uucore/src/lib/features/ringbuffer.rs b/src/uucore/src/lib/features/ringbuffer.rs
index 9a6176f92..08073fae0 100644
--- a/src/uucore/src/lib/features/ringbuffer.rs
+++ b/src/uucore/src/lib/features/ringbuffer.rs
@@ -33,21 +33,24 @@ use std::collections::VecDeque;
 /// let expected = VecDeque::from_iter([1, 2].iter());
 /// assert_eq!(expected, actual);
 /// ```
+///
+/// [`push_back`]: struct.RingBuffer.html#method.push_back
+/// [`from_iter`]: struct.RingBuffer.html#method.from_iter
 pub struct RingBuffer<T> {
     pub data: VecDeque<T>,
     size: usize,
 }
 
 impl<T> RingBuffer<T> {
-    pub fn new(size: usize) -> RingBuffer<T> {
-        RingBuffer {
+    pub fn new(size: usize) -> Self {
+        Self {
             data: VecDeque::new(),
             size,
         }
     }
 
-    pub fn from_iter(iter: impl Iterator<Item = T>, size: usize) -> RingBuffer<T> {
-        let mut ring_buffer = RingBuffer::new(size);
+    pub fn from_iter(iter: impl Iterator<Item = T>, size: usize) -> Self {
+        let mut ring_buffer = Self::new(size);
         for value in iter {
             ring_buffer.push_back(value);
         }
diff --git a/src/uu/printf/src/tokenize/mod.rs b/src/uucore/src/lib/features/tokenize/mod.rs
similarity index 100%
rename from src/uu/printf/src/tokenize/mod.rs
rename to src/uucore/src/lib/features/tokenize/mod.rs
diff --git a/src/uu/printf/src/tokenize/num_format/format_field.rs b/src/uucore/src/lib/features/tokenize/num_format/format_field.rs
similarity index 100%
rename from src/uu/printf/src/tokenize/num_format/format_field.rs
rename to src/uucore/src/lib/features/tokenize/num_format/format_field.rs
diff --git a/src/uu/printf/src/tokenize/num_format/formatter.rs b/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
similarity index 97%
rename from src/uu/printf/src/tokenize/num_format/formatter.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatter.rs
index 790c338ae..801e05eb8 100644
--- a/src/uu/printf/src/tokenize/num_format/formatter.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
@@ -1,9 +1,9 @@
 //! 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 uucore::{display::Quotable, show_error};
 
 use super::format_field::FormatField;
 
diff --git a/src/uu/printf/src/tokenize/num_format/formatters/base_conv/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
similarity index 96%
rename from src/uu/printf/src/tokenize/num_format/formatters/base_conv/mod.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
index a20f03a95..e6b1ea770 100644
--- a/src/uu/printf/src/tokenize/num_format/formatters/base_conv/mod.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
@@ -16,7 +16,7 @@ pub fn arrnum_int_mult(arr_num: &[u8], basenum: u8, base_ten_int_fact: u8) -> Ve
                 new_amount = (u16::from(*u) * fact) + carry;
                 rem = new_amount % base;
                 carry = (new_amount - rem) / base;
-                ret_rev.push(rem as u8)
+                ret_rev.push(rem as u8);
             }
             None => {
                 while carry != 0 {
@@ -32,23 +32,26 @@ pub fn arrnum_int_mult(arr_num: &[u8], basenum: u8, base_ten_int_fact: u8) -> Ve
     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>,
 }
 
-pub fn arrnum_int_div_step(
-    rem_in: Remainder,
+#[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 {
+) -> DivOut<'a> {
     let mut rem_out = Remainder {
         position: rem_in.position,
         replace: Vec::new(),
@@ -116,7 +119,7 @@ pub fn arrnum_int_add(arrnum: &[u8], basenum: u8, base_ten_int_term: u8) -> Vec<
                 new_amount = u16::from(*u) + carry;
                 rem = new_amount % base;
                 carry = (new_amount - rem) / base;
-                ret_rev.push(rem as u8)
+                ret_rev.push(rem as u8);
             }
             None => {
                 while carry != 0 {
@@ -141,6 +144,7 @@ pub fn base_conv_vec(src: &[u8], radix_src: u8, radix_dest: u8) -> Vec<u8> {
     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;
@@ -166,7 +170,7 @@ pub fn base_conv_float(src: &[u8], radix_src: u8, _radix_dest: u8) -> f64 {
             break;
         }
         factor /= radix_src_float;
-        r += factor * f64::from(*u)
+        r += factor * f64::from(*u);
     }
     r
 }
diff --git a/src/uu/printf/src/tokenize/num_format/formatters/base_conv/tests.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
similarity index 94%
rename from src/uu/printf/src/tokenize/num_format/formatters/base_conv/tests.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
index 7945d41ac..903a3faf1 100644
--- a/src/uu/printf/src/tokenize/num_format/formatters/base_conv/tests.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
@@ -49,7 +49,7 @@ fn test_arrnum_int_div_short_circuit() {
     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);
+    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/uu/printf/src/tokenize/num_format/formatters/cninetyninehexfloatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
similarity index 97%
rename from src/uu/printf/src/tokenize/num_format/formatters/cninetyninehexfloatf.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
index 0ca993680..85396a2aa 100644
--- a/src/uu/printf/src/tokenize/num_format/formatters/cninetyninehexfloatf.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
@@ -8,12 +8,14 @@ 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() -> CninetyNineHexFloatf {
-        CninetyNineHexFloatf { as_num: 0.0 }
+    pub fn new() -> Self {
+        Self::default()
     }
 }
 
@@ -91,6 +93,7 @@ fn get_primitive_hex(
     }
 }
 
+#[allow(dead_code)]
 fn to_hex(src: &str, before_decimal: bool) -> String {
     let radix_ten = base_conv::RadixTen;
     let radix_hex = base_conv::RadixHex;
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
new file mode 100644
index 000000000..07e1b3f47
--- /dev/null
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs
@@ -0,0 +1,185 @@
+// 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("".into());
+            if format.suffix == Some("e+00".into()) {
+                format.suffix = Some("".into());
+            }
+        } 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 = "".into();
+        }
+
+        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/uu/printf/src/tokenize/num_format/formatters/float_common.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
similarity index 85%
rename from src/uu/printf/src/tokenize/num_format/formatters/float_common.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
index 97009b586..eed543807 100644
--- a/src/uu/printf/src/tokenize/num_format/formatters/float_common.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
@@ -46,12 +46,12 @@ impl FloatAnalysis {
         max_sd_opt: Option<usize>,
         max_after_dec_opt: Option<usize>,
         hex_output: bool,
-    ) -> FloatAnalysis {
+    ) -> 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 = FloatAnalysis {
+        let mut ret = Self {
             len_important: 0,
             decimal_pos: None,
             follow: None,
@@ -153,7 +153,9 @@ fn de_hex(src: &str, before_decimal: bool) -> String {
 // bumps the last digit up one,
 // and if the digit was nine
 // propagate to the next, etc.
-fn _round_str_from(in_str: &str, position: usize) -> (String, bool) {
+// 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;
@@ -162,7 +164,14 @@ fn _round_str_from(in_str: &str, position: usize) -> (String, bool) {
         i -= 1;
         match c {
             '9' => {
-                rev.push('0');
+                // 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);
@@ -182,24 +191,32 @@ fn round_terminal_digit(
     before_dec: String,
     after_dec: String,
     position: usize,
-) -> (String, String) {
+) -> (String, String, bool) {
     if position < after_dec.len() {
         let digit_at_pos: char;
         {
-            digit_at_pos = (&after_dec[position..=position]).chars().next().expect("");
+            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);
+            let (new_after_dec, finished_in_dec) = _round_str_from(&after_dec, position, false);
             if finished_in_dec {
-                return (before_dec, new_after_dec);
+                return (before_dec, new_after_dec, false);
             } else {
-                let (new_before_dec, _) = _round_str_from(&before_dec, before_dec.len());
-                return (new_before_dec, new_after_dec);
+                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)
+    (before_dec, after_dec, false)
 }
 
 pub fn get_primitive_dec(
@@ -237,7 +254,7 @@ pub fn get_primitive_dec(
             String::from(second_segment_raw),
         ),
     };
-    let (pre_dec_unrounded, post_dec_unrounded, mantissa) = if sci_mode.is_some() {
+    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);
@@ -277,13 +294,15 @@ pub fn get_primitive_dec(
         (first_segment, second_segment, 0)
     };
 
-    let (pre_dec_draft, post_dec_draft) =
+    let (pre_dec_draft, post_dec_draft, dec_place_chg) =
         round_terminal_digit(pre_dec_unrounded, post_dec_unrounded, last_dec_place - 1);
-
-    f.pre_decimal = Some(pre_dec_draft);
     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!("{}+{:02}", si_ind, mantissa)
         } else {
@@ -291,6 +310,12 @@ pub fn get_primitive_dec(
             // leading zeroes
             format!("{}{:03}", si_ind, mantissa)
         });
+        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
diff --git a/src/uu/printf/src/tokenize/num_format/formatters/floatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
similarity index 94%
rename from src/uu/printf/src/tokenize/num_format/formatters/floatf.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
index afb2bcf08..e13629af5 100644
--- a/src/uu/printf/src/tokenize/num_format/formatters/floatf.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
@@ -6,10 +6,11 @@ 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() -> Floatf {
-        Floatf
+    pub fn new() -> Self {
+        Self::default()
     }
 }
 impl Formatter for Floatf {
diff --git a/src/uu/printf/src/tokenize/num_format/formatters/intf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
similarity index 97%
rename from src/uu/printf/src/tokenize/num_format/formatters/intf.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
index b6c18d436..0b93d134c 100644
--- a/src/uu/printf/src/tokenize/num_format/formatters/intf.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
@@ -11,6 +11,7 @@ use super::super::formatter::{
 use std::i64;
 use std::u64;
 
+#[derive(Default)]
 pub struct Intf {
     _a: u32,
 }
@@ -24,8 +25,8 @@ struct IntAnalysis {
 }
 
 impl Intf {
-    pub fn new() -> Intf {
-        Intf { _a: 0 }
+    pub fn new() -> Self {
+        Self::default()
     }
     // take a ref to argument string, and basic information
     // about prefix (offset, radix, sign), and analyze string
@@ -166,7 +167,7 @@ impl Intf {
                     fmt_prim.pre_decimal = Some(format!("{}", i));
                     fmt_prim
                 }
-                Err(_) => Intf::get_max(field_char, sign),
+                Err(_) => Self::get_max(field_char, sign),
             },
             _ => match u64::from_str_radix(segment, radix_in as u32) {
                 Ok(u) => {
@@ -180,7 +181,7 @@ impl Intf {
                     });
                     fmt_prim
                 }
-                Err(_) => Intf::get_max(field_char, sign),
+                Err(_) => Self::get_max(field_char, sign),
             },
         }
     }
@@ -196,7 +197,7 @@ impl Formatter for Intf {
 
         // get information about the string. see Intf::Analyze
         // def above.
-        let convert_hints = Intf::analyze(
+        let convert_hints = Self::analyze(
             str_in,
             *field.field_char == 'i' || *field.field_char == 'd',
             initial_prefix,
@@ -226,7 +227,7 @@ impl Formatter for Intf {
             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]);
-                Intf::conv_from_segment(
+                Self::conv_from_segment(
                     &segment,
                     initial_prefix.radix_in.clone(),
                     *field.field_char,
@@ -246,7 +247,7 @@ impl Formatter for Intf {
                 fmt_prim
             }
         } else {
-            Intf::get_max(*field.field_char, initial_prefix.sign)
+            Self::get_max(*field.field_char, initial_prefix.sign)
         })
     }
     fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
diff --git a/src/uu/printf/src/tokenize/num_format/formatters/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
similarity index 100%
rename from src/uu/printf/src/tokenize/num_format/formatters/mod.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
diff --git a/src/uu/printf/src/tokenize/num_format/formatters/scif.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
similarity index 94%
rename from src/uu/printf/src/tokenize/num_format/formatters/scif.rs
rename to src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
index c46c7d423..c5b88b5a7 100644
--- a/src/uu/printf/src/tokenize/num_format/formatters/scif.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
@@ -5,11 +5,12 @@ 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() -> Scif {
-        Scif
+    pub fn new() -> Self {
+        Self::default()
     }
 }
 impl Formatter for Scif {
diff --git a/src/uu/printf/src/tokenize/num_format/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/mod.rs
similarity index 100%
rename from src/uu/printf/src/tokenize/num_format/mod.rs
rename to src/uucore/src/lib/features/tokenize/num_format/mod.rs
diff --git a/src/uu/printf/src/tokenize/num_format/num_format.rs b/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
similarity index 98%
rename from src/uu/printf/src/tokenize/num_format/num_format.rs
rename to src/uucore/src/lib/features/tokenize/num_format/num_format.rs
index a9fee58e1..89d0fe89b 100644
--- a/src/uu/printf/src/tokenize/num_format/num_format.rs
+++ b/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
@@ -7,8 +7,8 @@
 use std::env;
 use std::vec::Vec;
 
-use uucore::display::Quotable;
-use uucore::{show_error, show_warning};
+use crate::display::Quotable;
+use crate::{show_error, show_warning};
 
 use super::format_field::{FieldType, FormatField};
 use super::formatter::{Base, FormatPrimitive, Formatter, InitialPrefix};
@@ -25,7 +25,7 @@ pub fn warn_expected_numeric(pf_arg: &str) {
 
 // when character constant arguments have excess characters
 // issue a warning when POSIXLY_CORRECT is not set
-fn warn_char_constant_ign(remaining_bytes: Vec<u8>) {
+fn warn_char_constant_ign(remaining_bytes: &[u8]) {
     match env::var("POSIXLY_CORRECT") {
         Ok(_) => {}
         Err(e) => {
@@ -59,7 +59,7 @@ fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
                                     ignored.push(cont);
                                 }
                                 if !ignored.is_empty() {
-                                    warn_char_constant_ign(ignored);
+                                    warn_char_constant_ign(&ignored);
                                 }
                                 second_byte as u8
                             }
diff --git a/src/uu/printf/src/tokenize/sub.rs b/src/uucore/src/lib/features/tokenize/sub.rs
similarity index 82%
rename from src/uu/printf/src/tokenize/sub.rs
rename to src/uucore/src/lib/features/tokenize/sub.rs
index 48d854fab..f8b5b5caf 100644
--- a/src/uu/printf/src/tokenize/sub.rs
+++ b/src/uucore/src/lib/features/tokenize/sub.rs
@@ -5,25 +5,40 @@
 //! 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 itertools::{put_back_n, PutBackN};
+use std::error::Error;
+use std::fmt::Display;
 use std::iter::Peekable;
 use std::process::exit;
 use std::slice::Iter;
 use std::str::Chars;
-use uucore::show_error;
 // use std::collections::HashSet;
 
 use super::num_format::format_field::{FieldType, FormatField};
 use super::num_format::num_format;
 use super::token;
 use super::unescaped_text::UnescapedText;
-use crate::cli;
 
-fn err_conv(sofar: &str) {
-    show_error!("%{}: invalid conversion specification", sofar);
-    exit(cli::EXIT_ERR);
+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, "%{}: invalid conversion specification", s),
+        }
+    }
+}
+
+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
@@ -59,6 +74,7 @@ pub struct Sub {
     field_char: char,
     field_type: FieldType,
     orig: String,
+    prefix_char: char,
 }
 impl Sub {
     pub fn new(
@@ -66,7 +82,8 @@ impl Sub {
         second_field: CanAsterisk<Option<u32>>,
         field_char: char,
         orig: String,
-    ) -> Sub {
+        prefix_char: char,
+    ) -> Self {
         // for more dry printing, field characters are grouped
         // in initialization of token.
         let field_type = match field_char {
@@ -80,19 +97,21 @@ impl Sub {
             _ => {
                 // should be unreachable.
                 println!("Invalid field type");
-                exit(cli::EXIT_ERR);
+                exit(EXIT_ERR);
             }
         };
-        Sub {
+        Self {
             min_width,
             second_field,
             field_char,
             field_type,
             orig,
+            prefix_char,
         }
     }
 }
 
+#[derive(Default)]
 struct SubParser {
     min_width_tmp: Option<String>,
     min_width_is_asterisk: bool,
@@ -105,34 +124,30 @@ struct SubParser {
 }
 
 impl SubParser {
-    fn new() -> SubParser {
-        SubParser {
-            min_width_tmp: None,
-            min_width_is_asterisk: false,
-            past_decimal: false,
-            second_field_tmp: None,
-            second_field_is_asterisk: false,
-            specifiers_found: false,
-            field_char: None,
-            text_so_far: String::new(),
-        }
+    fn new() -> Self {
+        Self::default()
     }
     fn from_it(
         it: &mut PutBackN<Chars>,
         args: &mut Peekable<Iter<String>>,
-    ) -> Option<Box<dyn token::Token>> {
-        let mut parser = SubParser::new();
-        if parser.sub_vals_retrieved(it) {
-            let t: Box<dyn token::Token> = SubParser::build_token(parser);
+    ) -> UResult<Option<Box<dyn token::Token>>> {
+        let mut parser = Self::new();
+        if parser.sub_vals_retrieved(it)? {
+            let t: Box<dyn token::Token> = Self::build_token(parser);
             t.print(args);
-            Some(t)
+            Ok(Some(t))
         } else {
-            None
+            Ok(None)
         }
     }
-    fn build_token(parser: SubParser) -> Box<dyn token::Token> {
+    fn build_token(parser: Self) -> Box<dyn 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',
+            _ => ' ',
+        };
+
         let t: Box<dyn token::Token> = Box::new(Sub::new(
             if parser.min_width_is_asterisk {
                 CanAsterisk::Asterisk
@@ -146,12 +161,13 @@ impl SubParser {
             },
             parser.field_char.unwrap(),
             parser.text_so_far,
+            prefix_char,
         ));
         t
     }
-    fn sub_vals_retrieved(&mut self, it: &mut PutBackN<Chars>) -> bool {
-        if !SubParser::successfully_eat_prefix(it, &mut self.text_so_far) {
-            return false;
+    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
@@ -175,7 +191,7 @@ impl SubParser {
                 '-' | '*' | '0'..='9' => {
                     if !self.past_decimal {
                         if self.min_width_is_asterisk || self.specifiers_found {
-                            err_conv(&self.text_so_far);
+                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
                         }
                         if self.min_width_tmp.is_none() {
                             self.min_width_tmp = Some(String::new());
@@ -183,7 +199,9 @@ impl SubParser {
                         match self.min_width_tmp.as_mut() {
                             Some(x) => {
                                 if (ch == '-' || ch == '*') && !x.is_empty() {
-                                    err_conv(&self.text_so_far);
+                                    return Err(
+                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
+                                    );
                                 }
                                 if ch == '*' {
                                     self.min_width_is_asterisk = true;
@@ -198,7 +216,7 @@ impl SubParser {
                         // second field should never have a
                         // negative value
                         if self.second_field_is_asterisk || ch == '-' || self.specifiers_found {
-                            err_conv(&self.text_so_far);
+                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
                         }
                         if self.second_field_tmp.is_none() {
                             self.second_field_tmp = Some(String::new());
@@ -206,7 +224,9 @@ impl SubParser {
                         match self.second_field_tmp.as_mut() {
                             Some(x) => {
                                 if ch == '*' && !x.is_empty() {
-                                    err_conv(&self.text_so_far);
+                                    return Err(
+                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
+                                    );
                                 }
                                 if ch == '*' {
                                     self.second_field_is_asterisk = true;
@@ -223,7 +243,7 @@ impl SubParser {
                     if !self.past_decimal {
                         self.past_decimal = true;
                     } else {
-                        err_conv(&self.text_so_far);
+                        return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
                     }
                 }
                 x if legal_fields.binary_search(&x).is_ok() => {
@@ -240,18 +260,18 @@ impl SubParser {
                     }
                 }
                 _ => {
-                    err_conv(&self.text_so_far);
+                    return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
                 }
             }
         }
         if self.field_char.is_none() {
-            err_conv(&self.text_so_far);
+            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);
+        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() {
@@ -260,9 +280,12 @@ impl SubParser {
             }
         }
 
-        true
+        Ok(true)
     }
-    fn successfully_eat_prefix(it: &mut PutBackN<Chars>, text_so_far: &mut String) -> bool {
+    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
@@ -272,25 +295,24 @@ impl SubParser {
             match n_ch {
                 Some(x) => {
                     it.put_back(x);
-                    true
+                    Ok(true)
                 }
                 None => {
                     text_so_far.push('%');
-                    err_conv(text_so_far);
-                    false
+                    Err(SubError::InvalidSpec(text_so_far.clone()).into())
                 }
             }
         } else {
             if let Some(x) = n_ch {
-                it.put_back(x)
+                it.put_back(x);
             };
             if let Some(x) = preface {
-                it.put_back(x)
+                it.put_back(x);
             };
-            false
+            Ok(false)
         }
     }
-    fn validate_field_params(&self, field_char: char) {
+    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
@@ -302,8 +324,12 @@ impl SubParser {
                     || self.past_decimal
                     || self.second_field_tmp.is_some()))
         {
-            err_conv(&self.text_so_far);
+            // invalid string substitution
+            // to do: include information about an invalid
+            // string substitution
+            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
         }
+        Ok(())
     }
 }
 
@@ -311,7 +337,7 @@ impl token::Tokenizer for Sub {
     fn from_it(
         it: &mut PutBackN<Chars>,
         args: &mut Peekable<Iter<String>>,
-    ) -> Option<Box<dyn token::Token>> {
+    ) -> UResult<Option<Box<dyn token::Token>>> {
         SubParser::from_it(it, args)
     }
 }
@@ -401,7 +427,7 @@ impl token::Token for Sub {
                                 final_str.push_str(&pre_min_width);
                             }
                             for _ in 0..diff {
-                                final_str.push(' ');
+                                final_str.push(self.prefix_char);
                             }
                             if pad_before {
                                 final_str.push_str(&pre_min_width);
diff --git a/src/uu/printf/src/tokenize/token.rs b/src/uucore/src/lib/features/tokenize/token.rs
similarity index 94%
rename from src/uu/printf/src/tokenize/token.rs
rename to src/uucore/src/lib/features/tokenize/token.rs
index 1d8ee5ead..6a25b620f 100644
--- a/src/uu/printf/src/tokenize/token.rs
+++ b/src/uucore/src/lib/features/tokenize/token.rs
@@ -4,6 +4,8 @@ use std::iter::Peekable;
 use std::slice::Iter;
 use std::str::Chars;
 
+use crate::error::UResult;
+
 // 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
@@ -27,5 +29,5 @@ pub trait Tokenizer {
     fn from_it(
         it: &mut PutBackN<Chars>,
         args: &mut Peekable<Iter<String>>,
-    ) -> Option<Box<dyn Token>>;
+    ) -> UResult<Option<Box<dyn Token>>>;
 }
diff --git a/src/uu/printf/src/tokenize/unescaped_text.rs b/src/uucore/src/lib/features/tokenize/unescaped_text.rs
similarity index 86%
rename from src/uu/printf/src/tokenize/unescaped_text.rs
rename to src/uucore/src/lib/features/tokenize/unescaped_text.rs
index 084014ae9..d186dbc26 100644
--- a/src/uu/printf/src/tokenize/unescaped_text.rs
+++ b/src/uucore/src/lib/features/tokenize/unescaped_text.rs
@@ -3,23 +3,45 @@
 //! 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
+// 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::{stdout, Write};
 use std::iter::Peekable;
 use std::process::exit;
 use std::slice::Iter;
 use std::str::Chars;
 
+use crate::error::UResult;
+
 use super::token;
 
-use crate::cli;
+const EXIT_OK: i32 = 0;
+const EXIT_ERR: i32 = 1;
 
+// by default stdout only flushes
+// to console when a newline is passed.
+fn flush_char(c: char) {
+    print!("{}", c);
+    let _ = stdout().flush();
+}
+
+fn flush_str(s: &str) {
+    print!("{}", s);
+    let _ = stdout().flush();
+}
+
+fn flush_bytes(bslice: &[u8]) {
+    let _ = stdout().write(bslice);
+    let _ = stdout().flush();
+}
+
+#[derive(Default)]
 pub struct UnescapedText(Vec<u8>);
 impl UnescapedText {
-    fn new() -> UnescapedText {
-        UnescapedText(Vec::new())
+    fn new() -> Self {
+        Self::default()
     }
     // take an iterator to the format string
     // consume between min and max chars
@@ -53,7 +75,7 @@ impl UnescapedText {
         if found < min_chars {
             // only ever expected for hex
             println!("missing hexadecimal number in escape"); //todo stderr
-            exit(cli::EXIT_ERR);
+            exit(EXIT_ERR);
         }
         retval
     }
@@ -76,7 +98,7 @@ impl UnescapedText {
         );
         if (val < 159 && (val != 36 && val != 64 && val != 96)) || (val > 55296 && val < 57343) {
             println!("{}", err_msg); //todo stderr
-            exit(cli::EXIT_ERR);
+            exit(EXIT_ERR);
         }
     }
     // pass an iterator that succeeds an '/',
@@ -114,10 +136,10 @@ impl UnescapedText {
                     _ => {}
                 }
                 if !ignore {
-                    let val = (UnescapedText::base_to_u32(min_len, max_len, base, it) % 256) as u8;
+                    let val = (Self::base_to_u32(min_len, max_len, base, it) % 256) as u8;
                     byte_vec.push(val);
                     let bvec = [val];
-                    cli::flush_bytes(&bvec);
+                    flush_bytes(&bvec);
                 } else {
                     byte_vec.push(ch as u8);
                 }
@@ -145,14 +167,14 @@ impl UnescapedText {
                     'f' => '\x0C',
                     // escape character
                     'e' => '\x1B',
-                    'c' => exit(cli::EXIT_OK),
+                    'c' => exit(EXIT_OK),
                     'u' | 'U' => {
                         let len = match e {
                             'u' => 4,
                             /* 'U' | */ _ => 8,
                         };
-                        let val = UnescapedText::base_to_u32(len, len, 16, it);
-                        UnescapedText::validate_iec(val, false);
+                        let val = Self::base_to_u32(len, len, 16, it);
+                        Self::validate_iec(val, false);
                         if let Some(c) = from_u32(val) {
                             c
                         } else {
@@ -165,7 +187,7 @@ impl UnescapedText {
                     }
                 };
                 s.push(ch);
-                cli::flush_str(&s);
+                flush_str(&s);
                 byte_vec.extend(s.bytes());
             }
         };
@@ -180,7 +202,7 @@ impl UnescapedText {
         subs_mode: bool,
     ) -> Option<Box<dyn token::Token>> {
         let mut addchar = false;
-        let mut new_text = UnescapedText::new();
+        let mut new_text = Self::new();
         let mut tmp_str = String::new();
         {
             let new_vec: &mut Vec<u8> = &mut (new_text.0);
@@ -193,7 +215,7 @@ impl UnescapedText {
                         // lazy branch eval
                         // remember this fn could be called
                         // many times in a single exec through %b
-                        cli::flush_char(ch);
+                        flush_char(ch);
                         tmp_str.push(ch);
                     }
                     '\\' => {
@@ -208,12 +230,12 @@ impl UnescapedText {
                             new_vec.extend(tmp_str.bytes());
                             tmp_str = String::new();
                         }
-                        UnescapedText::handle_escaped(new_vec, it, subs_mode)
+                        Self::handle_escaped(new_vec, it, subs_mode);
                     }
                     x if x == '%' && !subs_mode => {
                         if let Some(follow) = it.next() {
                             if follow == '%' {
-                                cli::flush_char(ch);
+                                flush_char(ch);
                                 tmp_str.push(ch);
                             } else {
                                 it.put_back(follow);
@@ -226,7 +248,7 @@ impl UnescapedText {
                         }
                     }
                     _ => {
-                        cli::flush_char(ch);
+                        flush_char(ch);
                         tmp_str.push(ch);
                     }
                 }
@@ -246,12 +268,12 @@ impl token::Tokenizer for UnescapedText {
     fn from_it(
         it: &mut PutBackN<Chars>,
         _: &mut Peekable<Iter<String>>,
-    ) -> Option<Box<dyn token::Token>> {
-        UnescapedText::from_it_core(it, false)
+    ) -> UResult<Option<Box<dyn token::Token>>> {
+        Ok(Self::from_it_core(it, false))
     }
 }
 impl token::Token for UnescapedText {
     fn print(&self, _: &mut Peekable<Iter<String>>) {
-        cli::flush_bytes(&self.0[..]);
+        flush_bytes(&self.0[..]);
     }
 }
diff --git a/src/uucore/src/lib/features/utmpx.rs b/src/uucore/src/lib/features/utmpx.rs
index a96c3f48c..2a0e2810b 100644
--- a/src/uucore/src/lib/features/utmpx.rs
+++ b/src/uucore/src/lib/features/utmpx.rs
@@ -221,11 +221,7 @@ impl Utmpx {
     pub fn canon_host(&self) -> IOResult<String> {
         let host = self.host();
 
-        // TODO: change to use `split_once` when MSRV hits 1.52.0
-        // let (hostname, display) = host.split_once(':').unwrap_or((&host, ""));
-        let mut h = host.split(':');
-        let hostname = h.next().unwrap_or(&host);
-        let display = h.next().unwrap_or("");
+        let (hostname, display) = host.split_once(':').unwrap_or((&host, ""));
 
         if !hostname.is_empty() {
             extern crate dns_lookup;
@@ -236,17 +232,20 @@ impl Utmpx {
                 flags: AI_CANONNAME,
                 ..AddrInfoHints::default()
             };
-            let sockets = getaddrinfo(Some(hostname), None, Some(hints))
-                .unwrap()
-                .collect::<IOResult<Vec<_>>>()?;
-            for socket in sockets {
-                if let Some(ai_canonname) = socket.canonname {
-                    return Ok(if display.is_empty() {
-                        ai_canonname
-                    } else {
-                        format!("{}:{}", ai_canonname, display)
-                    });
+            if let Ok(sockets) = getaddrinfo(Some(hostname), None, Some(hints)) {
+                let sockets = sockets.collect::<IOResult<Vec<_>>>()?;
+                for socket in sockets {
+                    if let Some(ai_canonname) = socket.canonname {
+                        return Ok(if display.is_empty() {
+                            ai_canonname
+                        } else {
+                            format!("{}:{}", ai_canonname, display)
+                        });
+                    }
                 }
+            } else {
+                // GNU coreutils has this behavior
+                return Ok(hostname.to_string());
             }
         }
 
@@ -319,7 +318,7 @@ impl UtmpxIter {
     fn new() -> Self {
         // PoisonErrors can safely be ignored
         let guard = LOCK.lock().unwrap_or_else(|err| err.into_inner());
-        UtmpxIter {
+        Self {
             guard,
             phantom: PhantomData,
         }
diff --git a/src/uucore/src/lib/features/wide.rs b/src/uucore/src/lib/features/wide.rs
index 49ce575a7..6b9368f50 100644
--- a/src/uucore/src/lib/features/wide.rs
+++ b/src/uucore/src/lib/features/wide.rs
@@ -27,10 +27,10 @@ pub trait FromWide {
     fn from_wide_null(wide: &[u16]) -> Self;
 }
 impl FromWide for String {
-    fn from_wide(wide: &[u16]) -> String {
+    fn from_wide(wide: &[u16]) -> Self {
         OsString::from_wide(wide).to_string_lossy().into_owned()
     }
-    fn from_wide_null(wide: &[u16]) -> String {
+    fn from_wide_null(wide: &[u16]) -> Self {
         let len = wide.iter().take_while(|&&c| c != 0).count();
         OsString::from_wide(&wide[..len])
             .to_string_lossy()
diff --git a/src/uucore/src/lib/lib.rs b/src/uucore/src/lib/lib.rs
index 3d2d867bd..8f3d045eb 100644
--- a/src/uucore/src/lib/lib.rs
+++ b/src/uucore/src/lib/lib.rs
@@ -16,9 +16,10 @@ mod macros; // crate macros (macro_rules-type; exported to `crate::...`)
 mod mods; // core cross-platform modules
 mod parser; // string parsing modules
 
+pub use uucore_procs::*;
+
 // * cross-platform modules
 pub use crate::mods::backup_control;
-pub use crate::mods::coreopts;
 pub use crate::mods::display;
 pub use crate::mods::error;
 pub use crate::mods::os;
@@ -37,6 +38,10 @@ pub use crate::features::encoding;
 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 = "ringbuffer")]
 pub use crate::features::ringbuffer;
 
@@ -76,12 +81,34 @@ use once_cell::sync::Lazy;
 
 use crate::display::Quotable;
 
+#[macro_export]
+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>
+            std::process::exit(code);
+        }
+    };
+}
+
+/// Generate the usage string for clap.
+///
+/// This function replaces all occurrences of `{}` with the execution phrase
+/// and leaks the result to return a `&'static str`. It does **not** support
+/// more advanced formatting features such as `{0}`.
+pub fn format_usage(s: &str) -> &'static str {
+    &*Box::leak(s.replace("{}", crate::execution_phrase()).into_boxed_str())
+}
+
 pub fn get_utility_is_second_arg() -> bool {
     crate::macros::UTILITY_IS_SECOND_ARG.load(Ordering::SeqCst)
 }
 
 pub fn set_utility_is_second_arg() {
-    crate::macros::UTILITY_IS_SECOND_ARG.store(true, Ordering::SeqCst)
+    crate::macros::UTILITY_IS_SECOND_ARG.store(true, Ordering::SeqCst);
 }
 
 // args_os() can be expensive to call, it copies all of argv before iterating.
@@ -135,8 +162,7 @@ pub enum ConversionResult {
 impl ConversionResult {
     pub fn accept_any(self) -> Vec<String> {
         match self {
-            Self::Complete(result) => result,
-            Self::Lossy(result) => result,
+            Self::Complete(result) | Self::Lossy(result) => result,
         }
     }
 
diff --git a/src/uucore/src/lib/macros.rs b/src/uucore/src/lib/macros.rs
index c7b15dba3..255ccd5b3 100644
--- a/src/uucore/src/lib/macros.rs
+++ b/src/uucore/src/lib/macros.rs
@@ -1,3 +1,35 @@
+//! Macros for the uucore utilities.
+//!
+//! This module bundles all macros used across the uucore utilities. These
+//! include macros for reporting errors in various formats, aborting program
+//! execution and more.
+//!
+//! To make use of all macros in this module, they must be imported like so:
+//!
+//! ```ignore
+//! #[macro_use]
+//! extern crate uucore;
+//! ```
+//!
+//! Alternatively, you can import single macros by importing them through their
+//! fully qualified name like this:
+//!
+//! ```no_run
+//! use uucore::{show, crash};
+//! ```
+//!
+//! Here's an overview of the macros sorted by purpose
+//!
+//! - Print errors
+//!   - From types implementing [`crate::error::UError`]: [`show!`],
+//!     [`show_if_err!`]
+//!   - From custom messages: [`show_error!`], [`show_usage_error!`]
+//! - Print warnings: [`show_warning!`]
+//! - Terminate util execution
+//!   - Crash program: [`crash!`], [`crash_if_err!`]
+
+// spell-checker:ignore sourcepath targetpath
+
 use std::sync::atomic::AtomicBool;
 
 // This file is part of the uutils coreutils package.
@@ -12,6 +44,45 @@ pub static UTILITY_IS_SECOND_ARG: AtomicBool = AtomicBool::new(false);
 
 //====
 
+/// Display a [`crate::error::UError`] and set global exit code.
+///
+/// Prints the error message contained in an [`crate::error::UError`] to stderr
+/// and sets the exit code through [`crate::error::set_exit_code`]. The printed
+/// error message is prepended with the calling utility's name. A call to this
+/// macro will not finish program execution.
+///
+/// # Examples
+///
+/// The following example would print a message "Some error occurred" and set
+/// the utility's exit code to 2.
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate uucore;
+///
+/// use uucore::error::{self, USimpleError};
+///
+/// fn main() {
+///     let err = USimpleError::new(2, "Some error occurred.");
+///     show!(err);
+///     assert_eq!(error::get_exit_code(), 2);
+/// }
+/// ```
+///
+/// If not using [`crate::error::UError`], one may achieve the same behavior
+/// like this:
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate uucore;
+///
+/// use uucore::error::set_exit_code;
+///
+/// fn main() {
+///     set_exit_code(2);
+///     show_error!("Some error occurred.");
+/// }
+/// ```
 #[macro_export]
 macro_rules! show(
     ($err:expr) => ({
@@ -21,6 +92,36 @@ macro_rules! show(
     })
 );
 
+/// Display an error and set global exit code in error case.
+///
+/// Wraps around [`show!`] and takes a [`crate::error::UResult`] instead of a
+/// [`crate::error::UError`] type. This macro invokes [`show!`] if the
+/// [`crate::error::UResult`] is an `Err`-variant. This can be invoked directly
+/// on the result of a function call, like in the `install` utility:
+///
+/// ```ignore
+/// show_if_err!(copy(sourcepath, &targetpath, b));
+/// ```
+///
+/// # Examples
+///
+/// ```ignore
+/// # #[macro_use]
+/// # extern crate uucore;
+/// # use uucore::error::{UError, UIoError, UResult, USimpleError};
+///
+/// # fn main() {
+/// let is_ok = Ok(1);
+/// // This does nothing at all
+/// show_if_err!(is_ok);
+///
+/// let is_err = Err(USimpleError::new(1, "I'm an error").into());
+/// // Calls `show!` on the contained USimpleError
+/// show_if_err!(is_err);
+/// # }
+/// ```
+///
+///
 #[macro_export]
 macro_rules! show_if_err(
     ($res:expr) => ({
@@ -31,6 +132,19 @@ macro_rules! show_if_err(
 );
 
 /// Show an error to stderr in a similar style to GNU coreutils.
+///
+/// Takes a [`format!`]-like input and prints it to stderr. The output is
+/// prepended with the current utility's name.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate uucore;
+/// # fn main() {
+/// show_error!("Couldn't apply {} to {}", "foo", "bar");
+/// # }
+/// ```
 #[macro_export]
 macro_rules! show_error(
     ($($args:tt)+) => ({
@@ -40,6 +154,17 @@ macro_rules! show_error(
 );
 
 /// Show a warning to stderr in a similar style to GNU coreutils.
+///
+/// Is this really required? Used in the following locations:
+///
+/// ./src/uu/head/src/head.rs:12
+/// ./src/uu/head/src/head.rs:424
+/// ./src/uu/head/src/head.rs:427
+/// ./src/uu/head/src/head.rs:430
+/// ./src/uu/head/src/head.rs:453
+/// ./src/uu/du/src/du.rs:339
+/// ./src/uu/wc/src/wc.rs:270
+/// ./src/uu/wc/src/wc.rs:273
 #[macro_export]
 macro_rules! show_error_custom_description (
     ($err:expr,$($args:tt)+) => ({
@@ -48,6 +173,21 @@ macro_rules! show_error_custom_description (
     })
 );
 
+/// Print a warning message to stderr.
+///
+/// Takes [`format!`]-compatible input and prepends it with the current
+/// utility's name and "warning: " before printing to stderr.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate uucore;
+/// # fn main() {
+/// // outputs <name>: warning: Couldn't apply foo to bar
+/// show_warning!("Couldn't apply {} to {}", "foo", "bar");
+/// # }
+/// ```
 #[macro_export]
 macro_rules! show_warning(
     ($($args:tt)+) => ({
@@ -57,6 +197,21 @@ macro_rules! show_warning(
 );
 
 /// Show a bad invocation help message in a similar style to GNU coreutils.
+///
+/// Takes a [`format!`]-compatible input and prepends it with the current
+/// utility's name before printing to stderr.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use]
+/// # extern crate uucore;
+/// # fn main() {
+/// // outputs <name>: Couldn't apply foo to bar
+/// //         Try '<name> --help' for more information.
+/// show_usage_error!("Couldn't apply {} to {}", "foo", "bar");
+/// # }
+/// ```
 #[macro_export]
 macro_rules! show_usage_error(
     ($($args:tt)+) => ({
@@ -66,27 +221,50 @@ macro_rules! show_usage_error(
     })
 );
 
-//====
-
-/// Calls `exit()` with the provided exit code.
-#[macro_export]
-macro_rules! exit(
-    ($exit_code:expr) => ({
-        ::std::process::exit($exit_code)
-    })
-);
-
-/// Display the provided error message, then `exit()` with the provided exit code
+/// Display an error and [`std::process::exit`]
+///
+/// Displays the provided error message using [`show_error!`], then invokes
+/// [`std::process::exit`] with the provided exit code.
+///
+/// # Examples
+///
+/// ```should_panic
+/// # #[macro_use]
+/// # extern crate uucore;
+/// # fn main() {
+/// // outputs <name>: Couldn't apply foo to bar
+/// // and terminates execution
+/// crash!(1, "Couldn't apply {} to {}", "foo", "bar");
+/// # }
+/// ```
 #[macro_export]
 macro_rules! crash(
     ($exit_code:expr, $($args:tt)+) => ({
         $crate::show_error!($($args)+);
-        $crate::exit!($exit_code)
+        std::process::exit($exit_code);
     })
 );
 
-/// Unwraps the Result. Instead of panicking, it exists the program with the
-/// provided exit code.
+/// Unwrap a [`std::result::Result`], crashing instead of panicking.
+///
+/// If the result is an `Ok`-variant, returns the value contained inside. If it
+/// is an `Err`-variant, invokes [`crash!`] with the formatted error instead.
+///
+/// # Examples
+///
+/// ```should_panic
+/// # #[macro_use]
+/// # extern crate uucore;
+/// # fn main() {
+/// let is_ok: Result<u32, &str> = Ok(1);
+/// // Does nothing
+/// crash_if_err!(1, is_ok);
+///
+/// let is_err: Result<u32, &str> = Err("This didn't work...");
+/// // Calls `crash!`
+/// crash_if_err!(1, is_err);
+/// # }
+/// ```
 #[macro_export]
 macro_rules! crash_if_err(
     ($exit_code:expr, $exp:expr) => (
@@ -96,120 +274,3 @@ macro_rules! crash_if_err(
         }
     )
 );
-
-//====
-
-#[macro_export]
-macro_rules! safe_write(
-    ($fd:expr, $($args:tt)+) => (
-        match write!($fd, $($args)+) {
-            Ok(_) => {}
-            Err(f) => panic!("{}", f)
-        }
-    )
-);
-
-#[macro_export]
-macro_rules! safe_writeln(
-    ($fd:expr, $($args:tt)+) => (
-        match writeln!($fd, $($args)+) {
-            Ok(_) => {}
-            Err(f) => panic!("{}", f)
-        }
-    )
-);
-
-//-- message templates
-
-//-- message templates : (join utility sub-macros)
-
-#[macro_export]
-macro_rules! snippet_list_join_oxford_comma {
-    ($conjunction:expr, $valOne:expr, $valTwo:expr) => (
-        format!("{}, {} {}", $valOne, $conjunction, $valTwo)
-    );
-    ($conjunction:expr, $valOne:expr, $valTwo:expr $(, $remaining_values:expr)*) => (
-        format!("{}, {}", $valOne, $crate::snippet_list_join_oxford_comma!($conjunction, $valTwo $(, $remaining_values)*))
-    );
-}
-
-#[macro_export]
-macro_rules! snippet_list_join {
-    ($conjunction:expr, $valOne:expr, $valTwo:expr) => (
-        format!("{} {} {}", $valOne, $conjunction, $valTwo)
-    );
-    ($conjunction:expr, $valOne:expr, $valTwo:expr $(, $remaining_values:expr)*) => (
-        format!("{}, {}", $valOne, $crate::snippet_list_join_oxford_comma!($conjunction, $valTwo $(, $remaining_values)*))
-    );
-}
-
-//-- message templates : invalid input
-
-#[macro_export]
-macro_rules! msg_invalid_input {
-    ($reason: expr) => {
-        format!("invalid input: {}", $reason)
-    };
-}
-
-// -- message templates : invalid input : flag
-
-#[macro_export]
-macro_rules! msg_invalid_opt_use {
-    ($about:expr, $flag:expr) => {
-        $crate::msg_invalid_input!(format!("The '{}' option {}", $flag, $about))
-    };
-    ($about:expr, $long_flag:expr, $short_flag:expr) => {
-        $crate::msg_invalid_input!(format!(
-            "The '{}' ('{}') option {}",
-            $long_flag, $short_flag, $about
-        ))
-    };
-}
-
-#[macro_export]
-macro_rules! msg_opt_only_usable_if {
-    ($clause:expr, $flag:expr) => {
-        $crate::msg_invalid_opt_use!(format!("only usable if {}", $clause), $flag)
-    };
-    ($clause:expr, $long_flag:expr, $short_flag:expr) => {
-        $crate::msg_invalid_opt_use!(
-            format!("only usable if {}", $clause),
-            $long_flag,
-            $short_flag
-        )
-    };
-}
-
-#[macro_export]
-macro_rules! msg_opt_invalid_should_be {
-    ($expects:expr, $received:expr, $flag:expr) => {
-        $crate::msg_invalid_opt_use!(
-            format!("expects {}, but was provided {}", $expects, $received),
-            $flag
-        )
-    };
-    ($expects:expr, $received:expr, $long_flag:expr, $short_flag:expr) => {
-        $crate::msg_invalid_opt_use!(
-            format!("expects {}, but was provided {}", $expects, $received),
-            $long_flag,
-            $short_flag
-        )
-    };
-}
-
-// -- message templates : invalid input : input combinations
-
-#[macro_export]
-macro_rules! msg_expects_one_of {
-    ($valOne:expr $(, $remaining_values:expr)*) => (
-        $crate::msg_invalid_input!(format!("expects one of {}", $crate::snippet_list_join!("or", $valOne $(, $remaining_values)*)))
-    );
-}
-
-#[macro_export]
-macro_rules! msg_expects_no_more_than_one_of {
-    ($valOne:expr $(, $remaining_values:expr)*) => (
-        $crate::msg_invalid_input!(format!("expects no more than one of {}", $crate::snippet_list_join!("or", $valOne $(, $remaining_values)*))) ;
-    );
-}
diff --git a/src/uucore/src/lib/mods.rs b/src/uucore/src/lib/mods.rs
index 8f6d14976..bbde696dc 100644
--- a/src/uucore/src/lib/mods.rs
+++ b/src/uucore/src/lib/mods.rs
@@ -1,7 +1,6 @@
 // mods ~ cross-platforms modules (core/bundler file)
 
 pub mod backup_control;
-pub mod coreopts;
 pub mod display;
 pub mod error;
 pub mod os;
diff --git a/src/uucore/src/lib/mods/backup_control.rs b/src/uucore/src/lib/mods/backup_control.rs
index acb7342b7..f2da374b6 100644
--- a/src/uucore/src/lib/mods/backup_control.rs
+++ b/src/uucore/src/lib/mods/backup_control.rs
@@ -34,29 +34,29 @@
 //! #[macro_use]
 //! extern crate uucore;
 //!
-//! use clap::{App, Arg, ArgMatches};
+//! use clap::{Command, Arg, ArgMatches};
 //! use std::path::{Path, PathBuf};
 //! use uucore::backup_control::{self, BackupMode};
 //! use uucore::error::{UError, UResult};
 //!
 //! fn main() {
-//!     let usage = String::from("app [OPTION]... ARG");
+//!     let usage = String::from("command [OPTION]... ARG");
 //!     let long_usage = String::from("And here's a detailed explanation");
 //!
-//!     let matches = App::new("app")
+//!     let matches = Command::new("command")
 //!         .arg(backup_control::arguments::backup())
 //!         .arg(backup_control::arguments::backup_no_args())
 //!         .arg(backup_control::arguments::suffix())
-//!         .usage(&usage[..])
+//!         .override_usage(&usage[..])
 //!         .after_help(&*format!(
 //!             "{}\n{}",
 //!             long_usage,
 //!             backup_control::BACKUP_CONTROL_LONG_HELP
 //!         ))
 //!         .get_matches_from(vec![
-//!             "app", "--backup=t", "--suffix=bak~"
+//!             "command", "--backup=t", "--suffix=bak~"
 //!         ]);
-//!    
+//!
 //!     let backup_mode = match backup_control::determine_backup_mode(&matches) {
 //!         Err(e) => {
 //!             show!(e);
@@ -129,7 +129,7 @@ pub enum BackupMode {
 /// Backup error types.
 ///
 /// Errors are currently raised by [`determine_backup_mode`] only. All errors
-/// are implemented as [`UCustomError`] for uniform handling across utilities.
+/// are implemented as [`UError`] for uniform handling across utilities.
 #[derive(Debug, Eq, PartialEq)]
 pub enum BackupError {
     /// An invalid argument (e.g. 'foo') was given as backup type. First
@@ -206,8 +206,8 @@ pub mod arguments {
     pub static OPT_SUFFIX: &str = "backupopt_suffix";
 
     /// '--backup' argument
-    pub fn backup() -> clap::Arg<'static, 'static> {
-        clap::Arg::with_name(OPT_BACKUP)
+    pub fn backup<'a>() -> clap::Arg<'a> {
+        clap::Arg::new(OPT_BACKUP)
             .long("backup")
             .help("make a backup of each existing destination file")
             .takes_value(true)
@@ -217,20 +217,21 @@ pub mod arguments {
     }
 
     /// '-b' argument
-    pub fn backup_no_args() -> clap::Arg<'static, 'static> {
-        clap::Arg::with_name(OPT_BACKUP_NO_ARG)
-            .short("b")
+    pub fn backup_no_args<'a>() -> clap::Arg<'a> {
+        clap::Arg::new(OPT_BACKUP_NO_ARG)
+            .short('b')
             .help("like --backup but does not accept an argument")
     }
 
     /// '-S, --suffix' argument
-    pub fn suffix() -> clap::Arg<'static, 'static> {
-        clap::Arg::with_name(OPT_SUFFIX)
-            .short("S")
+    pub fn suffix<'a>() -> clap::Arg<'a> {
+        clap::Arg::new(OPT_SUFFIX)
+            .short('S')
             .long("suffix")
             .help("override the usual backup suffix")
             .takes_value(true)
             .value_name("SUFFIX")
+            .allow_hyphen_values(true)
     }
 }
 
@@ -289,14 +290,14 @@ pub fn determine_backup_suffix(matches: &ArgMatches) -> String {
 /// #[macro_use]
 /// extern crate uucore;
 /// use uucore::backup_control::{self, BackupMode};
-/// use clap::{App, Arg, ArgMatches};
+/// use clap::{Command, Arg, ArgMatches};
 ///
 /// fn main() {
-///     let matches = App::new("app")
+///     let matches = Command::new("command")
 ///         .arg(backup_control::arguments::backup())
 ///         .arg(backup_control::arguments::backup_no_args())
 ///         .get_matches_from(vec![
-///             "app", "-b", "--backup=t"
+///             "command", "-b", "--backup=t"
 ///         ]);
 ///
 ///     let backup_mode = backup_control::determine_backup_mode(&matches).unwrap();
@@ -312,16 +313,16 @@ pub fn determine_backup_suffix(matches: &ArgMatches) -> String {
 /// #[macro_use]
 /// extern crate uucore;
 /// use uucore::backup_control::{self, BackupMode, BackupError};
-/// use clap::{App, Arg, ArgMatches};
+/// use clap::{Command, Arg, ArgMatches};
 ///
 /// fn main() {
-///     let matches = App::new("app")
+///     let matches = Command::new("command")
 ///         .arg(backup_control::arguments::backup())
 ///         .arg(backup_control::arguments::backup_no_args())
 ///         .get_matches_from(vec![
-///             "app", "-b", "--backup=n"
+///             "command", "-b", "--backup=n"
 ///         ]);
-///    
+///
 ///     let backup_mode = backup_control::determine_backup_mode(&matches);
 ///
 ///     assert!(backup_mode.is_err());
@@ -445,7 +446,7 @@ mod tests {
     use super::*;
     use std::env;
     // Required to instantiate mutex in shared context
-    use clap::App;
+    use clap::Command;
     use lazy_static::lazy_static;
     use std::sync::Mutex;
 
@@ -462,8 +463,8 @@ mod tests {
     // Environment variable for "VERSION_CONTROL"
     static ENV_VERSION_CONTROL: &str = "VERSION_CONTROL";
 
-    fn make_app() -> clap::App<'static, 'static> {
-        App::new("app")
+    fn make_app() -> clap::Command<'static> {
+        Command::new("command")
             .arg(arguments::backup())
             .arg(arguments::backup_no_args())
             .arg(arguments::suffix())
@@ -473,7 +474,7 @@ mod tests {
     #[test]
     fn test_backup_mode_short_only() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        let matches = make_app().get_matches_from(vec!["app", "-b"]);
+        let matches = make_app().get_matches_from(vec!["command", "-b"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
@@ -484,7 +485,7 @@ mod tests {
     #[test]
     fn test_backup_mode_long_preferred_over_short() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        let matches = make_app().get_matches_from(vec!["app", "-b", "--backup=none"]);
+        let matches = make_app().get_matches_from(vec!["command", "-b", "--backup=none"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
@@ -495,7 +496,7 @@ mod tests {
     #[test]
     fn test_backup_mode_long_without_args_no_env() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        let matches = make_app().get_matches_from(vec!["app", "--backup"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
@@ -506,7 +507,7 @@ mod tests {
     #[test]
     fn test_backup_mode_long_with_args() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        let matches = make_app().get_matches_from(vec!["app", "--backup=simple"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup=simple"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
@@ -517,7 +518,7 @@ mod tests {
     #[test]
     fn test_backup_mode_long_with_args_invalid() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        let matches = make_app().get_matches_from(vec!["app", "--backup=foobar"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup=foobar"]);
 
         let result = determine_backup_mode(&matches);
 
@@ -530,7 +531,7 @@ mod tests {
     #[test]
     fn test_backup_mode_long_with_args_ambiguous() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        let matches = make_app().get_matches_from(vec!["app", "--backup=n"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup=n"]);
 
         let result = determine_backup_mode(&matches);
 
@@ -543,7 +544,7 @@ mod tests {
     #[test]
     fn test_backup_mode_long_with_arg_shortened() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        let matches = make_app().get_matches_from(vec!["app", "--backup=si"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup=si"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
@@ -555,7 +556,7 @@ mod tests {
     fn test_backup_mode_short_only_ignore_env() {
         let _dummy = TEST_MUTEX.lock().unwrap();
         env::set_var(ENV_VERSION_CONTROL, "none");
-        let matches = make_app().get_matches_from(vec!["app", "-b"]);
+        let matches = make_app().get_matches_from(vec!["command", "-b"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
@@ -568,7 +569,7 @@ mod tests {
     fn test_backup_mode_long_without_args_with_env() {
         let _dummy = TEST_MUTEX.lock().unwrap();
         env::set_var(ENV_VERSION_CONTROL, "none");
-        let matches = make_app().get_matches_from(vec!["app", "--backup"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
@@ -581,7 +582,7 @@ mod tests {
     fn test_backup_mode_long_with_env_var_invalid() {
         let _dummy = TEST_MUTEX.lock().unwrap();
         env::set_var(ENV_VERSION_CONTROL, "foobar");
-        let matches = make_app().get_matches_from(vec!["app", "--backup"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches);
 
@@ -596,7 +597,7 @@ mod tests {
     fn test_backup_mode_long_with_env_var_ambiguous() {
         let _dummy = TEST_MUTEX.lock().unwrap();
         env::set_var(ENV_VERSION_CONTROL, "n");
-        let matches = make_app().get_matches_from(vec!["app", "--backup"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches);
 
@@ -611,11 +612,20 @@ mod tests {
     fn test_backup_mode_long_with_env_var_shortened() {
         let _dummy = TEST_MUTEX.lock().unwrap();
         env::set_var(ENV_VERSION_CONTROL, "si");
-        let matches = make_app().get_matches_from(vec!["app", "--backup"]);
+        let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
         assert_eq!(result, BackupMode::SimpleBackup);
         env::remove_var(ENV_VERSION_CONTROL);
     }
+
+    #[test]
+    fn test_suffix_takes_hyphen_value() {
+        let _dummy = TEST_MUTEX.lock().unwrap();
+        let matches = make_app().get_matches_from(vec!["command", "-b", "--suffix", "-v"]);
+
+        let result = determine_backup_suffix(&matches);
+        assert_eq!(result, "-v");
+    }
 }
diff --git a/src/uucore/src/lib/mods/coreopts.rs b/src/uucore/src/lib/mods/coreopts.rs
deleted file mode 100644
index b534ff902..000000000
--- a/src/uucore/src/lib/mods/coreopts.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-pub struct HelpText<'a> {
-    pub name: &'a str,
-    pub version: &'a str,
-    pub syntax: &'a str,
-    pub summary: &'a str,
-    pub long_help: &'a str,
-    pub display_usage: bool,
-}
-
-pub struct CoreOptions<'a> {
-    options: getopts::Options,
-    help_text: HelpText<'a>,
-}
-
-impl<'a> CoreOptions<'a> {
-    pub fn new(help_text: HelpText<'a>) -> Self {
-        let mut ret = CoreOptions {
-            options: getopts::Options::new(),
-            help_text,
-        };
-        ret.options
-            .optflag("", "help", "print usage information")
-            .optflag("", "version", "print name and version number");
-        ret
-    }
-    pub fn optflagopt(
-        &mut self,
-        short_name: &str,
-        long_name: &str,
-        desc: &str,
-        hint: &str,
-    ) -> &mut CoreOptions<'a> {
-        self.options.optflagopt(short_name, long_name, desc, hint);
-        self
-    }
-    pub fn optflag(
-        &mut self,
-        short_name: &str,
-        long_name: &str,
-        desc: &str,
-    ) -> &mut CoreOptions<'a> {
-        self.options.optflag(short_name, long_name, desc);
-        self
-    }
-    pub fn optflagmulti(
-        &mut self,
-        short_name: &str,
-        long_name: &str,
-        desc: &str,
-    ) -> &mut CoreOptions<'a> {
-        self.options.optflagmulti(short_name, long_name, desc);
-        self
-    }
-    pub fn optopt(
-        &mut self,
-        short_name: &str,
-        long_name: &str,
-        desc: &str,
-        hint: &str,
-    ) -> &mut CoreOptions<'a> {
-        self.options.optopt(short_name, long_name, desc, hint);
-        self
-    }
-    pub fn optmulti(
-        &mut self,
-        short_name: &str,
-        long_name: &str,
-        desc: &str,
-        hint: &str,
-    ) -> &mut CoreOptions<'a> {
-        self.options.optmulti(short_name, long_name, desc, hint);
-        self
-    }
-    pub fn usage(&self, summary: &str) -> String {
-        self.options.usage(summary)
-    }
-    pub fn parse(&mut self, args: Vec<String>) -> getopts::Matches {
-        let matches = match self.options.parse(&args[1..]) {
-            Ok(m) => Some(m),
-            Err(f) => {
-                eprint!("{}: error: ", self.help_text.name);
-                eprintln!("{}", f);
-                ::std::process::exit(1);
-            }
-        }
-        .unwrap();
-        if matches.opt_present("help") {
-            let usage_str = if self.help_text.display_usage {
-                format!(
-                    "\n {}\n\n Reference\n",
-                    self.options.usage(self.help_text.summary)
-                )
-                .replace("Options:", " Options:")
-            } else {
-                String::new()
-            };
-            print!(
-                "
- {0} {1}
-
- {0} {2}
-{3}{4}
-",
-                self.help_text.name,
-                self.help_text.version,
-                self.help_text.syntax,
-                usage_str,
-                self.help_text.long_help
-            );
-            crate::exit!(0);
-        } else if matches.opt_present("version") {
-            println!("{} {}", self.help_text.name, self.help_text.version);
-            crate::exit!(0);
-        }
-        matches
-    }
-}
-
-#[macro_export]
-macro_rules! app {
-    ($syntax: expr, $summary: expr, $long_help: expr) => {
-        uucore::coreopts::CoreOptions::new(uucore::coreopts::HelpText {
-            name: uucore::util_name(),
-            version: env!("CARGO_PKG_VERSION"),
-            syntax: $syntax,
-            summary: $summary,
-            long_help: $long_help,
-            display_usage: true,
-        })
-    };
-    ($syntax: expr, $summary: expr, $long_help: expr, $display_usage: expr) => {
-        uucore::coreopts::CoreOptions::new(uucore::coreopts::HelpText {
-            name: uucore::util_name(),
-            version: env!("CARGO_PKG_VERSION"),
-            syntax: $syntax,
-            summary: $summary,
-            long_help: $long_help,
-            display_usage: $display_usage,
-        })
-    };
-}
diff --git a/src/uucore/src/lib/mods/display.rs b/src/uucore/src/lib/mods/display.rs
index dfe64184f..95288973a 100644
--- a/src/uucore/src/lib/mods/display.rs
+++ b/src/uucore/src/lib/mods/display.rs
@@ -19,378 +19,16 @@
 /// println_verbatim(path)?; // Prints "foo/bar.baz"
 /// # Ok::<(), std::io::Error>(())
 /// ```
-// spell-checker:ignore Fbar
-use std::borrow::Cow;
 use std::ffi::OsStr;
-#[cfg(any(unix, target_os = "wasi", windows))]
-use std::fmt::Write as FmtWrite;
-use std::fmt::{self, Display, Formatter};
 use std::io::{self, Write as IoWrite};
 
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
 #[cfg(target_os = "wasi")]
 use std::os::wasi::ffi::OsStrExt;
-#[cfg(any(unix, target_os = "wasi"))]
-use std::str::from_utf8;
 
-/// An extension trait for displaying filenames to users.
-pub trait Quotable {
-    /// Returns an object that implements [`Display`] for printing filenames with
-    /// proper quoting and escaping for the platform.
-    ///
-    /// On Unix this corresponds to sh/bash syntax, on Windows Powershell syntax
-    /// is used.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    /// use uucore::display::Quotable;
-    ///
-    /// let path = Path::new("foo/bar.baz");
-    ///
-    /// println!("Found file {}", path.quote()); // Prints "Found file 'foo/bar.baz'"
-    /// ```
-    fn quote(&self) -> Quoted<'_>;
-
-    /// Like `quote()`, but don't actually add quotes unless necessary because of
-    /// whitespace or special characters.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::path::Path;
-    /// use uucore::display::Quotable;
-    /// use uucore::show_error;
-    ///
-    /// let foo = Path::new("foo/bar.baz");
-    /// let bar = Path::new("foo bar");
-    ///
-    /// show_error!("{}: Not found", foo.maybe_quote()); // Prints "util: foo/bar.baz: Not found"
-    /// show_error!("{}: Not found", bar.maybe_quote()); // Prints "util: 'foo bar': Not found"
-    /// ```
-    fn maybe_quote(&self) -> Quoted<'_> {
-        let mut quoted = self.quote();
-        quoted.force_quote = false;
-        quoted
-    }
-}
-
-macro_rules! impl_as_ref {
-    ($type: ty) => {
-        impl Quotable for $type {
-            fn quote(&self) -> Quoted<'_> {
-                Quoted::new(self.as_ref())
-            }
-        }
-    };
-}
-
-impl_as_ref!(str);
-impl_as_ref!(&'_ str);
-impl_as_ref!(String);
-impl_as_ref!(std::path::Path);
-impl_as_ref!(&'_ std::path::Path);
-impl_as_ref!(std::path::PathBuf);
-impl_as_ref!(std::path::Component<'_>);
-impl_as_ref!(std::path::Components<'_>);
-impl_as_ref!(std::path::Iter<'_>);
-impl_as_ref!(std::ffi::OsStr);
-impl_as_ref!(&'_ std::ffi::OsStr);
-impl_as_ref!(std::ffi::OsString);
-
-// Cow<'_, str> does not implement AsRef<OsStr> and this is unlikely to be fixed
-// for backward compatibility reasons. Otherwise we'd use a blanket impl.
-impl Quotable for Cow<'_, str> {
-    fn quote(&self) -> Quoted<'_> {
-        let text: &str = self.as_ref();
-        Quoted::new(text.as_ref())
-    }
-}
-
-impl Quotable for Cow<'_, std::path::Path> {
-    fn quote(&self) -> Quoted<'_> {
-        let text: &std::path::Path = self.as_ref();
-        Quoted::new(text.as_ref())
-    }
-}
-
-/// A wrapper around [`OsStr`] for printing paths with quoting and escaping applied.
-#[derive(Debug, Copy, Clone)]
-pub struct Quoted<'a> {
-    text: &'a OsStr,
-    force_quote: bool,
-}
-
-impl<'a> Quoted<'a> {
-    fn new(text: &'a OsStr) -> Self {
-        Quoted {
-            text,
-            force_quote: true,
-        }
-    }
-}
-
-impl Display for Quoted<'_> {
-    #[cfg(any(windows, unix, target_os = "wasi"))]
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        // On Unix we emulate sh syntax. On Windows Powershell.
-        // They're just similar enough to share some code.
-
-        /// Characters with special meaning outside quotes.
-        // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_02
-        // I don't know why % is in there, and GNU doesn't quote it either.
-        // {} were used in a version elsewhere but seem unnecessary, GNU doesn't
-        // quote them. They're used in function definitions but not in a way we
-        // have to worry about.
-        #[cfg(any(unix, target_os = "wasi"))]
-        const SPECIAL_SHELL_CHARS: &[u8] = b"|&;<>()$`\\\"'*?[]=";
-        // FIXME: I'm not a PowerShell wizard and don't know if this is correct.
-        // I just copied the Unix version, removed \, and added ,{} based on
-        // experimentation.
-        // I have noticed that ~?*[] only get expanded in some contexts, so watch
-        // out for that if doing your own tests.
-        // Get-ChildItem seems unwilling to quote anything so it doesn't help.
-        // There's the additional wrinkle that Windows has stricter requirements
-        // for filenames: I've been testing using a Linux build of PowerShell, but
-        // this code doesn't even compile on Linux.
-        #[cfg(windows)]
-        const SPECIAL_SHELL_CHARS: &[u8] = b"|&;<>()$`\"'*?[]=,{}";
-
-        /// Characters with a special meaning at the beginning of a name.
-        // ~ expands a home directory.
-        // # starts a comment.
-        // ! is a common extension for expanding the shell history.
-        #[cfg(any(unix, target_os = "wasi"))]
-        const SPECIAL_SHELL_CHARS_START: &[char] = &['~', '#', '!'];
-        // Same deal as before, this is possibly incomplete.
-        // A single stand-alone exclamation mark seems to have some special meaning.
-        #[cfg(windows)]
-        const SPECIAL_SHELL_CHARS_START: &[char] = &['~', '#', '@', '!'];
-
-        /// Characters that are interpreted specially in a double-quoted string.
-        #[cfg(any(unix, target_os = "wasi"))]
-        const DOUBLE_UNSAFE: &[u8] = &[b'"', b'`', b'$', b'\\'];
-        #[cfg(windows)]
-        const DOUBLE_UNSAFE: &[u8] = &[b'"', b'`', b'$'];
-
-        let text = match self.text.to_str() {
-            None => return write_escaped(f, self.text),
-            Some(text) => text,
-        };
-
-        let mut is_single_safe = true;
-        let mut is_double_safe = true;
-        let mut requires_quote = self.force_quote;
-
-        if let Some(first) = text.chars().next() {
-            if SPECIAL_SHELL_CHARS_START.contains(&first) {
-                requires_quote = true;
-            }
-            // Unlike in Unix, quoting an argument may stop it
-            // from being recognized as an option. I like that very much.
-            // But we don't want to quote "-" because that's a common
-            // special argument and PowerShell doesn't mind it.
-            #[cfg(windows)]
-            if first == '-' && text.len() > 1 {
-                requires_quote = true;
-            }
-        } else {
-            // Empty string
-            requires_quote = true;
-        }
-
-        for ch in text.chars() {
-            if ch.is_ascii() {
-                let ch = ch as u8;
-                if ch == b'\'' {
-                    is_single_safe = false;
-                }
-                if DOUBLE_UNSAFE.contains(&ch) {
-                    is_double_safe = false;
-                }
-                if !requires_quote && SPECIAL_SHELL_CHARS.contains(&ch) {
-                    requires_quote = true;
-                }
-                if ch.is_ascii_control() {
-                    return write_escaped(f, self.text);
-                }
-            }
-            if !requires_quote && ch.is_whitespace() {
-                // This includes unicode whitespace.
-                // We maybe don't have to escape it, we don't escape other lookalike
-                // characters either, but it's confusing if it goes unquoted.
-                requires_quote = true;
-            }
-        }
-
-        if !requires_quote {
-            return f.write_str(text);
-        } else if is_single_safe {
-            return write_simple(f, text, '\'');
-        } else if is_double_safe {
-            return write_simple(f, text, '\"');
-        } else {
-            return write_single_escaped(f, text);
-        }
-
-        fn write_simple(f: &mut Formatter<'_>, text: &str, quote: char) -> fmt::Result {
-            f.write_char(quote)?;
-            f.write_str(text)?;
-            f.write_char(quote)?;
-            Ok(())
-        }
-
-        #[cfg(any(unix, target_os = "wasi"))]
-        fn write_single_escaped(f: &mut Formatter<'_>, text: &str) -> fmt::Result {
-            let mut iter = text.split('\'');
-            if let Some(chunk) = iter.next() {
-                if !chunk.is_empty() {
-                    write_simple(f, chunk, '\'')?;
-                }
-            }
-            for chunk in iter {
-                f.write_str("\\'")?;
-                if !chunk.is_empty() {
-                    write_simple(f, chunk, '\'')?;
-                }
-            }
-            Ok(())
-        }
-
-        /// Write using the syntax described here:
-        /// https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
-        ///
-        /// Supported by these shells:
-        /// - bash
-        /// - zsh
-        /// - busybox sh
-        /// - mksh
-        ///
-        /// Not supported by these:
-        /// - fish
-        /// - dash
-        /// - tcsh
-        #[cfg(any(unix, target_os = "wasi"))]
-        fn write_escaped(f: &mut Formatter<'_>, text: &OsStr) -> fmt::Result {
-            f.write_str("$'")?;
-            for chunk in from_utf8_iter(text.as_bytes()) {
-                match chunk {
-                    Ok(chunk) => {
-                        for ch in chunk.chars() {
-                            match ch {
-                                '\n' => f.write_str("\\n")?,
-                                '\t' => f.write_str("\\t")?,
-                                '\r' => f.write_str("\\r")?,
-                                // We could do \b, \f, \v, etc., but those are
-                                // rare enough to be confusing.
-                                // \0 doesn't work consistently because of the
-                                // octal \nnn syntax, and null bytes can't appear
-                                // in filenames anyway.
-                                ch if ch.is_ascii_control() => write!(f, "\\x{:02X}", ch as u8)?,
-                                '\\' | '\'' => {
-                                    // '?' and '"' can also be escaped this way
-                                    // but AFAICT there's no reason to do so
-                                    f.write_char('\\')?;
-                                    f.write_char(ch)?;
-                                }
-                                ch => {
-                                    f.write_char(ch)?;
-                                }
-                            }
-                        }
-                    }
-                    Err(unit) => write!(f, "\\x{:02X}", unit)?,
-                }
-            }
-            f.write_char('\'')?;
-            Ok(())
-        }
-
-        #[cfg(windows)]
-        fn write_single_escaped(f: &mut Formatter<'_>, text: &str) -> fmt::Result {
-            // Quotes in Powershell can be escaped by doubling them
-            f.write_char('\'')?;
-            let mut iter = text.split('\'');
-            if let Some(chunk) = iter.next() {
-                f.write_str(chunk)?;
-            }
-            for chunk in iter {
-                f.write_str("''")?;
-                f.write_str(chunk)?;
-            }
-            f.write_char('\'')?;
-            Ok(())
-        }
-
-        #[cfg(windows)]
-        fn write_escaped(f: &mut Formatter<'_>, text: &OsStr) -> fmt::Result {
-            // ` takes the role of \ since \ is already used as the path separator.
-            // Things are UTF-16-oriented, so we escape code units as "`u{1234}".
-            use std::char::decode_utf16;
-            use std::os::windows::ffi::OsStrExt;
-
-            f.write_char('"')?;
-            for ch in decode_utf16(text.encode_wide()) {
-                match ch {
-                    Ok(ch) => match ch {
-                        '\0' => f.write_str("`0")?,
-                        '\r' => f.write_str("`r")?,
-                        '\n' => f.write_str("`n")?,
-                        '\t' => f.write_str("`t")?,
-                        ch if ch.is_ascii_control() => write!(f, "`u{{{:04X}}}", ch as u8)?,
-                        '`' => f.write_str("``")?,
-                        '$' => f.write_str("`$")?,
-                        '"' => f.write_str("\"\"")?,
-                        ch => f.write_char(ch)?,
-                    },
-                    Err(err) => write!(f, "`u{{{:04X}}}", err.unpaired_surrogate())?,
-                }
-            }
-            f.write_char('"')?;
-            Ok(())
-        }
-    }
-
-    #[cfg(not(any(unix, target_os = "wasi", windows)))]
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        // As a fallback, we use Rust's own escaping rules.
-        // This is reasonably sane and very easy to implement.
-        // We use single quotes because that's hardcoded in a lot of tests.
-        let text = self.text.to_string_lossy();
-        if self.force_quote || !text.chars().all(|ch| ch.is_alphanumeric() || ch == '.') {
-            write!(f, "'{}'", text.escape_debug())
-        } else {
-            f.write_str(&text)
-        }
-    }
-}
-
-#[cfg(any(unix, target_os = "wasi"))]
-fn from_utf8_iter(mut bytes: &[u8]) -> impl Iterator<Item = Result<&str, u8>> {
-    std::iter::from_fn(move || {
-        if bytes.is_empty() {
-            return None;
-        }
-        match from_utf8(bytes) {
-            Ok(text) => {
-                bytes = &[];
-                Some(Ok(text))
-            }
-            Err(err) if err.valid_up_to() == 0 => {
-                let res = bytes[0];
-                bytes = &bytes[1..];
-                Some(Err(res))
-            }
-            Err(err) => {
-                let (valid, rest) = bytes.split_at(err.valid_up_to());
-                bytes = rest;
-                Some(Ok(from_utf8(valid).unwrap()))
-            }
-        }
-    })
-}
+// These used to be defined here, but they live in their own crate now.
+pub use os_display::{Quotable, Quoted};
 
 /// Print a path (or `OsStr`-like object) directly to stdout, with a trailing newline,
 /// without losing any information if its encoding is invalid.
@@ -429,129 +67,3 @@ pub fn print_verbatim<S: AsRef<OsStr>>(text: S) -> io::Result<()> {
         write!(stdout, "{}", std::path::Path::new(text.as_ref()).display())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn verify_quote(cases: &[(impl Quotable, &str)]) {
-        for (case, expected) in cases {
-            assert_eq!(case.quote().to_string(), *expected);
-        }
-    }
-
-    fn verify_maybe(cases: &[(impl Quotable, &str)]) {
-        for (case, expected) in cases {
-            assert_eq!(case.maybe_quote().to_string(), *expected);
-        }
-    }
-
-    /// This should hold on any platform, or else other tests fail.
-    #[test]
-    fn test_basic() {
-        verify_quote(&[
-            ("foo", "'foo'"),
-            ("", "''"),
-            ("foo/bar.baz", "'foo/bar.baz'"),
-        ]);
-        verify_maybe(&[
-            ("foo", "foo"),
-            ("", "''"),
-            ("foo bar", "'foo bar'"),
-            ("$foo", "'$foo'"),
-            ("-", "-"),
-        ]);
-    }
-
-    #[cfg(any(unix, target_os = "wasi", windows))]
-    #[test]
-    fn test_common() {
-        verify_maybe(&[
-            ("a#b", "a#b"),
-            ("#ab", "'#ab'"),
-            ("a~b", "a~b"),
-            ("!", "'!'"),
-        ]);
-    }
-
-    #[cfg(any(unix, target_os = "wasi"))]
-    #[test]
-    fn test_unix() {
-        verify_quote(&[
-            ("can't", r#""can't""#),
-            (r#"can'"t"#, r#"'can'\''"t'"#),
-            (r#"can'$t"#, r#"'can'\''$t'"#),
-            ("foo\nb\ta\r\\\0`r", r#"$'foo\nb\ta\r\\\x00`r'"#),
-            ("foo\x02", r#"$'foo\x02'"#),
-            (r#"'$''"#, r#"\''$'\'\'"#),
-        ]);
-        verify_quote(&[(OsStr::from_bytes(b"foo\xFF"), r#"$'foo\xFF'"#)]);
-        verify_maybe(&[
-            ("-x", "-x"),
-            ("a,b", "a,b"),
-            ("a\\b", "'a\\b'"),
-            ("}", ("}")),
-        ]);
-    }
-
-    #[cfg(windows)]
-    #[test]
-    fn test_windows() {
-        use std::ffi::OsString;
-        use std::os::windows::ffi::OsStringExt;
-        verify_quote(&[
-            (r#"foo\bar"#, r#"'foo\bar'"#),
-            ("can't", r#""can't""#),
-            (r#"can'"t"#, r#"'can''"t'"#),
-            (r#"can'$t"#, r#"'can''$t'"#),
-            ("foo\nb\ta\r\\\0`r", r#""foo`nb`ta`r\`0``r""#),
-            ("foo\x02", r#""foo`u{0002}""#),
-            (r#"'$''"#, r#"'''$'''''"#),
-        ]);
-        verify_quote(&[(
-            OsString::from_wide(&[b'x' as u16, 0xD800]),
-            r#""x`u{D800}""#,
-        )]);
-        verify_maybe(&[
-            ("-x", "'-x'"),
-            ("a,b", "'a,b'"),
-            ("a\\b", "a\\b"),
-            ("}", "'}'"),
-        ]);
-    }
-
-    #[cfg(any(unix, target_os = "wasi"))]
-    #[test]
-    fn test_utf8_iter() {
-        type ByteStr = &'static [u8];
-        type Chunk = Result<&'static str, u8>;
-        const CASES: &[(ByteStr, &[Chunk])] = &[
-            (b"", &[]),
-            (b"hello", &[Ok("hello")]),
-            // Immediately invalid
-            (b"\xFF", &[Err(b'\xFF')]),
-            // Incomplete UTF-8
-            (b"\xC2", &[Err(b'\xC2')]),
-            (b"\xF4\x8F", &[Err(b'\xF4'), Err(b'\x8F')]),
-            (b"\xFF\xFF", &[Err(b'\xFF'), Err(b'\xFF')]),
-            (b"hello\xC2", &[Ok("hello"), Err(b'\xC2')]),
-            (b"\xFFhello", &[Err(b'\xFF'), Ok("hello")]),
-            (b"\xFF\xC2hello", &[Err(b'\xFF'), Err(b'\xC2'), Ok("hello")]),
-            (b"foo\xFFbar", &[Ok("foo"), Err(b'\xFF'), Ok("bar")]),
-            (
-                b"foo\xF4\x8Fbar",
-                &[Ok("foo"), Err(b'\xF4'), Err(b'\x8F'), Ok("bar")],
-            ),
-            (
-                b"foo\xFF\xC2bar",
-                &[Ok("foo"), Err(b'\xFF'), Err(b'\xC2'), Ok("bar")],
-            ),
-        ];
-        for &(case, expected) in CASES {
-            assert_eq!(
-                from_utf8_iter(case).collect::<Vec<_>>().as_slice(),
-                expected
-            );
-        }
-    }
-}
diff --git a/src/uucore/src/lib/mods/error.rs b/src/uucore/src/lib/mods/error.rs
index c04a0f2f1..dbe4d5bc1 100644
--- a/src/uucore/src/lib/mods/error.rs
+++ b/src/uucore/src/lib/mods/error.rs
@@ -50,6 +50,7 @@
 
 // spell-checker:ignore uioerror
 
+use clap;
 use std::{
     error::Error,
     fmt::{Display, Formatter},
@@ -139,7 +140,7 @@ pub type UResult<T> = Result<T, Box<dyn UError>>;
 /// The main routine would look like this:
 ///
 /// ```ignore
-/// #[uucore_procs::gen_uumain]
+/// #[uucore::main]
 /// pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 ///     // Perform computations here ...
 ///     return Err(LsError::InvalidLineWidth(String::from("test")).into())
@@ -265,7 +266,7 @@ impl<T> From<T> for Box<dyn UError>
 where
     T: UError + 'static,
 {
-    fn from(t: T) -> Box<dyn UError> {
+    fn from(t: T) -> Self {
         Box::new(t)
     }
 }
@@ -371,7 +372,7 @@ impl UError for UUsageError {
 /// ```
 #[derive(Debug)]
 pub struct UIoError {
-    context: String,
+    context: Option<String>,
     inner: std::io::Error,
 }
 
@@ -379,7 +380,7 @@ impl UIoError {
     #[allow(clippy::new_ret_no_self)]
     pub fn new<S: Into<String>>(kind: std::io::ErrorKind, context: S) -> Box<dyn UError> {
         Box::new(Self {
-            context: context.into(),
+            context: Some(context.into()),
             inner: kind.into(),
         })
     }
@@ -435,7 +436,11 @@ impl Display for UIoError {
             capitalize(&mut message);
             &message
         };
-        write!(f, "{}: {}", self.context, message)
+        if let Some(ctx) = &self.context {
+            write!(f, "{}: {}", ctx, message)
+        } else {
+            write!(f, "{}", message)
+        }
     }
 }
 
@@ -464,7 +469,7 @@ pub trait FromIo<T> {
 impl FromIo<Box<UIoError>> for std::io::Error {
     fn map_err_context(self, context: impl FnOnce() -> String) -> Box<UIoError> {
         Box::new(UIoError {
-            context: (context)(),
+            context: Some((context)()),
             inner: self,
         })
     }
@@ -479,12 +484,28 @@ impl<T> FromIo<UResult<T>> for std::io::Result<T> {
 impl FromIo<Box<UIoError>> for std::io::ErrorKind {
     fn map_err_context(self, context: impl FnOnce() -> String) -> Box<UIoError> {
         Box::new(UIoError {
-            context: (context)(),
+            context: Some((context)()),
             inner: std::io::Error::new(self, ""),
         })
     }
 }
 
+impl From<std::io::Error> for UIoError {
+    fn from(f: std::io::Error) -> Self {
+        Self {
+            context: None,
+            inner: f,
+        }
+    }
+}
+
+impl From<std::io::Error> for Box<dyn UError> {
+    fn from(f: std::io::Error) -> Self {
+        let u_error: UIoError = f.into();
+        Box::new(u_error) as Self
+    }
+}
+
 /// Shorthand to construct [`UIoError`]-instances.
 ///
 /// This macro serves as a convenience call to quickly construct instances of
@@ -595,3 +616,13 @@ impl From<i32> for Box<dyn UError> {
         ExitCode::new(i)
     }
 }
+
+/// Implementations for clap::Error
+impl UError for clap::Error {
+    fn code(&self) -> i32 {
+        match self.kind() {
+            clap::ErrorKind::DisplayHelp | clap::ErrorKind::DisplayVersion => 0,
+            _ => 1,
+        }
+    }
+}
diff --git a/src/uucore/src/lib/mods/panic.rs b/src/uucore/src/lib/mods/panic.rs
index ebba10429..5a1e20d80 100644
--- a/src/uucore/src/lib/mods/panic.rs
+++ b/src/uucore/src/lib/mods/panic.rs
@@ -26,17 +26,17 @@ fn is_broken_pipe(info: &PanicInfo) -> bool {
 ///
 /// For background discussions on `SIGPIPE` handling, see
 ///
-/// * https://github.com/uutils/coreutils/issues/374
-/// * https://github.com/uutils/coreutils/pull/1106
-/// * https://github.com/rust-lang/rust/issues/62569
-/// * https://github.com/BurntSushi/ripgrep/issues/200
-/// * https://github.com/crev-dev/cargo-crev/issues/287
+/// * `<https://github.com/uutils/coreutils/issues/374>`
+/// * `<https://github.com/uutils/coreutils/pull/1106>`
+/// * `<https://github.com/rust-lang/rust/issues/62569>`
+/// * `<https://github.com/BurntSushi/ripgrep/issues/200>`
+/// * `<https://github.com/crev-dev/cargo-crev/issues/287>`
 ///
 pub fn mute_sigpipe_panic() {
     let hook = panic::take_hook();
     panic::set_hook(Box::new(move |info| {
         if !is_broken_pipe(info) {
-            hook(info)
+            hook(info);
         }
     }));
 }
diff --git a/src/uucore/src/lib/mods/ranges.rs b/src/uucore/src/lib/mods/ranges.rs
index f142e14fb..822c09e02 100644
--- a/src/uucore/src/lib/mods/ranges.rs
+++ b/src/uucore/src/lib/mods/ranges.rs
@@ -20,7 +20,7 @@ pub struct Range {
 impl FromStr for Range {
     type Err = &'static str;
 
-    fn from_str(s: &str) -> Result<Range, &'static str> {
+    fn from_str(s: &str) -> Result<Self, &'static str> {
         use std::usize::MAX;
 
         let mut parts = s.splitn(2, '-');
@@ -33,7 +33,7 @@ impl FromStr for Range {
             (Some(nm), None) => {
                 if let Ok(nm) = nm.parse::<usize>() {
                     if nm > 0 {
-                        Ok(Range { low: nm, high: nm })
+                        Ok(Self { low: nm, high: nm })
                     } else {
                         Err(field)
                     }
@@ -44,7 +44,7 @@ impl FromStr for Range {
             (Some(n), Some(m)) if m.is_empty() => {
                 if let Ok(low) = n.parse::<usize>() {
                     if low > 0 {
-                        Ok(Range { low, high: MAX - 1 })
+                        Ok(Self { low, high: MAX - 1 })
                     } else {
                         Err(field)
                     }
@@ -55,7 +55,7 @@ impl FromStr for Range {
             (Some(n), Some(m)) if n.is_empty() => {
                 if let Ok(high) = m.parse::<usize>() {
                     if high > 0 {
-                        Ok(Range { low: 1, high })
+                        Ok(Self { low: 1, high })
                     } else {
                         Err(field)
                     }
@@ -66,7 +66,7 @@ impl FromStr for Range {
             (Some(n), Some(m)) => match (n.parse::<usize>(), m.parse::<usize>()) {
                 (Ok(low), Ok(high)) => {
                     if low > 0 && low <= high {
-                        Ok(Range { low, high })
+                        Ok(Self { low, high })
                     } else if low == 0 {
                         Err(field)
                     } else {
@@ -81,10 +81,10 @@ impl FromStr for Range {
 }
 
 impl Range {
-    pub fn from_list(list: &str) -> Result<Vec<Range>, String> {
+    pub fn from_list(list: &str) -> Result<Vec<Self>, String> {
         use std::cmp::max;
 
-        let mut ranges: Vec<Range> = vec![];
+        let mut ranges: Vec<Self> = vec![];
 
         for item in list.split(',') {
             let range_item = FromStr::from_str(item)
diff --git a/src/uucore/src/lib/parser/parse_size.rs b/src/uucore/src/lib/parser/parse_size.rs
index c05c0d3f1..e68c04e5c 100644
--- a/src/uucore/src/lib/parser/parse_size.rs
+++ b/src/uucore/src/lib/parser/parse_size.rs
@@ -33,14 +33,14 @@ use crate::display::Quotable;
 /// assert_eq!(Ok(9 * 1000), parse_size("9kB")); // kB is 1000
 /// assert_eq!(Ok(2 * 1024), parse_size("2K")); // K is 1024
 /// ```
-pub fn parse_size(size: &str) -> Result<usize, ParseSizeError> {
+pub fn parse_size(size: &str) -> Result<u64, ParseSizeError> {
     if size.is_empty() {
         return Err(ParseSizeError::parse_failure(size));
     }
     // Get the numeric part of the size argument. For example, if the
     // argument is "123K", then the numeric part is "123".
     let numeric_string: String = size.chars().take_while(|c| c.is_digit(10)).collect();
-    let number: usize = if !numeric_string.is_empty() {
+    let number: u64 = if !numeric_string.is_empty() {
         match numeric_string.parse() {
             Ok(n) => n,
             Err(_) => return Err(ParseSizeError::parse_failure(size)),
@@ -75,7 +75,7 @@ pub fn parse_size(size: &str) -> Result<usize, ParseSizeError> {
         "YB" | "yB" => (1000, 8),
         _ => return Err(ParseSizeError::parse_failure(size)),
     };
-    let factor = match usize::try_from(base.pow(exponent)) {
+    let factor = match u64::try_from(base.pow(exponent)) {
         Ok(n) => n,
         Err(_) => return Err(ParseSizeError::size_too_big(size)),
     };
@@ -102,8 +102,7 @@ impl Error for ParseSizeError {
 impl fmt::Display for ParseSizeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         let s = match self {
-            ParseSizeError::ParseFailure(s) => s,
-            ParseSizeError::SizeTooBig(s) => s,
+            ParseSizeError::ParseFailure(s) | ParseSizeError::SizeTooBig(s) => s,
         };
         write!(f, "{}", s)
     }
@@ -113,7 +112,7 @@ impl fmt::Display for ParseSizeError {
 // but there's a lot of downstream code that constructs these errors manually
 // that would be affected
 impl ParseSizeError {
-    fn parse_failure(s: &str) -> ParseSizeError {
+    fn parse_failure(s: &str) -> Self {
         // stderr on linux (GNU coreutils 8.32) (LC_ALL=C)
         // has to be handled in the respective uutils because strings differ, e.g.:
         //
@@ -145,10 +144,10 @@ impl ParseSizeError {
         //                   --width
         //                   --strings
         // etc.
-        ParseSizeError::ParseFailure(format!("{}", s.quote()))
+        Self::ParseFailure(format!("{}", s.quote()))
     }
 
-    fn size_too_big(s: &str) -> ParseSizeError {
+    fn size_too_big(s: &str) -> Self {
         // stderr on linux (GNU coreutils 8.32) (LC_ALL=C)
         // has to be handled in the respective uutils because strings differ, e.g.:
         //
@@ -165,7 +164,7 @@ impl ParseSizeError {
         // stderr on macos (brew - GNU coreutils 8.32) also differs for the same version, e.g.:
         // ghead:   invalid number of bytes: '1Y': Value too large to be stored in data type
         // gtail:   invalid number of bytes: '1Y': Value too large to be stored in data type
-        ParseSizeError::SizeTooBig(format!(
+        Self::SizeTooBig(format!(
             "{}: Value too large for defined data type",
             s.quote()
         ))
@@ -182,7 +181,7 @@ mod tests {
 
     #[test]
     fn all_suffixes() {
-        // Units  are  K,M,G,T,P,E,Z,Y  (powers  of 1024) or KB,MB,... (powers of 1000).
+        // Units  are  K,M,G,T,P,E,Z,Y (powers of 1024) or KB,MB,... (powers of 1000).
         // Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
         let suffixes = [
             ('K', 1u32),
@@ -191,31 +190,30 @@ mod tests {
             ('T', 4u32),
             ('P', 5u32),
             ('E', 6u32),
-            #[cfg(target_pointer_width = "128")]
-            ('Z', 7u32), // ParseSizeError::SizeTooBig on x64
-            #[cfg(target_pointer_width = "128")]
-            ('Y', 8u32), // ParseSizeError::SizeTooBig on x64
+            // The following will always result ParseSizeError::SizeTooBig as they cannot fit in u64
+            // ('Z', 7u32),
+            // ('Y', 8u32),
         ];
 
         for &(c, exp) in &suffixes {
             let s = format!("2{}B", c); // KB
-            assert_eq!(Ok((2 * (1000_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok((2 * (1000_u128).pow(exp)) as u64), parse_size(&s));
             let s = format!("2{}", c); // K
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
             let s = format!("2{}iB", c); // KiB
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
             let s = format!("2{}iB", c.to_lowercase()); // kiB
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
 
             // suffix only
             let s = format!("{}B", c); // KB
-            assert_eq!(Ok(((1000_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok(((1000_u128).pow(exp)) as u64), parse_size(&s));
             let s = format!("{}", c); // K
-            assert_eq!(Ok(((1024_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
             let s = format!("{}iB", c); // KiB
-            assert_eq!(Ok(((1024_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
             let s = format!("{}iB", c.to_lowercase()); // kiB
-            assert_eq!(Ok(((1024_u128).pow(exp)) as usize), parse_size(&s));
+            assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
         }
     }
 
@@ -240,19 +238,6 @@ mod tests {
         );
     }
 
-    #[test]
-    #[cfg(target_pointer_width = "32")]
-    fn overflow_x32() {
-        assert!(variant_eq(
-            &parse_size("1T").unwrap_err(),
-            &ParseSizeError::SizeTooBig(String::new())
-        ));
-        assert!(variant_eq(
-            &parse_size("1000G").unwrap_err(),
-            &ParseSizeError::SizeTooBig(String::new())
-        ));
-    }
-
     #[test]
     fn invalid_syntax() {
         let test_strings = [
diff --git a/src/uucore/src/lib/parser/parse_time.rs b/src/uucore/src/lib/parser/parse_time.rs
index 68f0ca8d0..e440a3c91 100644
--- a/src/uucore/src/lib/parser/parse_time.rs
+++ b/src/uucore/src/lib/parser/parse_time.rs
@@ -6,11 +6,46 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (vars) NANOS numstr
+//! Parsing a duration from a string.
+//!
+//! Use the [`from_str`] function to parse a [`Duration`] from a string.
 
 use std::time::Duration;
 
 use crate::display::Quotable;
 
+/// Parse a duration from a string.
+///
+/// The string may contain only a number, like "123" or "4.5", or it
+/// may contain a number with a unit specifier, like "123s" meaning
+/// one hundred twenty three seconds or "4.5d" meaning four and a half
+/// days. If no unit is specified, the unit is assumed to be seconds.
+///
+/// The only allowed suffixes are
+///
+/// * "s" for seconds,
+/// * "m" for minutes,
+/// * "h" for hours,
+/// * "d" for days.
+///
+/// This function uses [`Duration::saturating_mul`] to compute the
+/// number of seconds, so it does not overflow. If overflow would have
+/// occurred, [`Duration::MAX`] is returned instead.
+///
+/// # Errors
+///
+/// This function returns an error if the input string is empty, the
+/// input is not a valid number, or the unit specifier is invalid or
+/// unknown.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::time::Duration;
+/// use uucore::parse_time::from_str;
+/// assert_eq!(from_str("123"), Ok(Duration::from_secs(123)));
+/// assert_eq!(from_str("2d"), Ok(Duration::from_secs(60 * 60 * 24 * 2)));
+/// ```
 pub fn from_str(string: &str) -> Result<Duration, String> {
     let len = string.len();
     if len == 0 {
@@ -18,10 +53,10 @@ pub fn from_str(string: &str) -> Result<Duration, String> {
     }
     let slice = &string[..len - 1];
     let (numstr, times) = match string.chars().next_back().unwrap() {
-        's' | 'S' => (slice, 1),
-        'm' | 'M' => (slice, 60),
-        'h' | 'H' => (slice, 60 * 60),
-        'd' | 'D' => (slice, 60 * 60 * 24),
+        's' => (slice, 1),
+        'm' => (slice, 60),
+        'h' => (slice, 60 * 60),
+        'd' => (slice, 60 * 60 * 24),
         val if !val.is_alphabetic() => (string, 1),
         _ => {
             if string == "inf" || string == "infinity" {
@@ -35,9 +70,64 @@ pub fn from_str(string: &str) -> Result<Duration, String> {
         .parse::<f64>()
         .map_err(|e| format!("invalid time interval {}: {}", string.quote(), e))?;
 
+    if num < 0. {
+        return Err(format!("invalid time interval {}", string.quote()));
+    }
+
     const NANOS_PER_SEC: u32 = 1_000_000_000;
     let whole_secs = num.trunc();
     let nanos = (num.fract() * (NANOS_PER_SEC as f64)).trunc();
     let duration = Duration::new(whole_secs as u64, nanos as u32);
-    Ok(duration * times)
+    Ok(duration.saturating_mul(times))
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::parse_time::from_str;
+    use std::time::Duration;
+
+    #[test]
+    fn test_no_units() {
+        assert_eq!(from_str("123"), Ok(Duration::from_secs(123)));
+    }
+
+    #[test]
+    fn test_units() {
+        assert_eq!(from_str("2d"), Ok(Duration::from_secs(60 * 60 * 24 * 2)));
+    }
+
+    #[test]
+    fn test_saturating_mul() {
+        assert_eq!(from_str("9223372036854775808d"), Ok(Duration::MAX));
+    }
+
+    #[test]
+    fn test_error_empty() {
+        assert!(from_str("").is_err());
+    }
+
+    #[test]
+    fn test_error_invalid_unit() {
+        assert!(from_str("123X").is_err());
+    }
+
+    #[test]
+    fn test_error_invalid_magnitude() {
+        assert!(from_str("12abc3s").is_err());
+    }
+
+    #[test]
+    fn test_negative() {
+        assert!(from_str("-1").is_err());
+    }
+
+    /// Test that capital letters are not allowed in suffixes.
+    #[test]
+    fn test_no_capital_letters() {
+        assert!(from_str("1S").is_err());
+        assert!(from_str("1M").is_err());
+        assert!(from_str("1H").is_err());
+        assert!(from_str("1D").is_err());
+    }
 }
diff --git a/src/uucore_procs/Cargo.toml b/src/uucore_procs/Cargo.toml
index 3efe80e00..151c308cf 100644
--- a/src/uucore_procs/Cargo.toml
+++ b/src/uucore_procs/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "uucore_procs"
-version = "0.0.7"
+version = "0.0.13"
 authors = ["Roy Ivy III <rivy.dev@gmail.com>"]
 license = "MIT"
 description = "uutils ~ 'uucore' proc-macros"
 
-homepage = "https://github.com/uutils/uucore/uucore_procs"
-repository = "https://github.com/uutils/uucore/uucore_procs"
+homepage = "https://github.com/uutils/coreutils"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uucore_procs"
 # readme = "README.md"
 keywords = ["cross-platform", "proc-macros", "uucore", "uutils"]
 # categories = ["os"]
@@ -18,9 +18,3 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version="1.0", features = ["full"] }
-
-[features]
-default = []
-# * non-default features
-debug = ["syn/extra-traits"] ## add Debug traits to syn structures (for `println!("{:?}", ...)`)
diff --git a/src/uucore_procs/LICENSE b/src/uucore_procs/LICENSE
new file mode 120000
index 000000000..30cff7403
--- /dev/null
+++ b/src/uucore_procs/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
\ No newline at end of file
diff --git a/src/uucore_procs/src/lib.rs b/src/uucore_procs/src/lib.rs
index 13b1dae3b..3a32dab83 100644
--- a/src/uucore_procs/src/lib.rs
+++ b/src/uucore_procs/src/lib.rs
@@ -2,100 +2,20 @@
 
 extern crate proc_macro;
 use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
 use quote::quote;
-use syn::{self, parse_macro_input, ItemFn};
 
 //## rust proc-macro background info
 //* ref: <https://dev.to/naufraghi/procedural-macro-in-rust-101-k3f> @@ <http://archive.is/Vbr5e>
 //* ref: [path construction from LitStr](https://oschwald.github.io/maxminddb-rust/syn/struct.LitStr.html) @@ <http://archive.is/8YDua>
 
-//## proc_dbg macro
-//* used to help debug the compile-time proc_macro code
-
-#[cfg(feature = "debug")]
-macro_rules! proc_dbg {
-    ($x:expr) => {
-        dbg!($x)
-    };
-}
-#[cfg(not(feature = "debug"))]
-macro_rules! proc_dbg {
-    ($x:expr) => {};
-}
-
-//## main!()
-
-// main!( EXPR )
-// generates a `main()` function for utilities within the uutils group
-// EXPR == syn::Expr::Lit::String | syn::Expr::Path::Ident ~ EXPR contains the lexical path to the utility `uumain()` function
-//* NOTE: EXPR is ultimately expected to be a multi-segment lexical path (eg, `crate::func`); so, if a single segment path is provided, a trailing "::uumain" is automatically added
-//* for more generic use (and future use of "eager" macros), EXPR may be in either STRING or IDENT form
-
-struct Tokens {
-    expr: syn::Expr,
-}
-
-impl syn::parse::Parse for Tokens {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        Ok(Tokens {
-            expr: input.parse()?,
-        })
-    }
-}
-
-#[proc_macro]
-pub fn main(stream: TokenStream) -> TokenStream {
-    let Tokens { expr } = syn::parse_macro_input!(stream as Tokens);
-    proc_dbg!(&expr);
-
-    const ARG_PANIC_TEXT: &str =
-        "expected ident lexical path (or a literal string version) to 'uumain()' as argument";
-
-    // match EXPR as a string literal or an ident path, o/w panic!()
-    let mut expr = match expr {
-        syn::Expr::Lit(expr_lit) => match expr_lit.lit {
-            syn::Lit::Str(ref lit_str) => lit_str.parse::<syn::ExprPath>().unwrap(),
-            _ => panic!("{}", ARG_PANIC_TEXT),
-        },
-        syn::Expr::Path(expr_path) => expr_path,
-        _ => panic!("{}", ARG_PANIC_TEXT),
-    };
-    proc_dbg!(&expr);
-
-    // for a single segment ExprPath argument, add trailing '::uumain' segment
-    if expr.path.segments.len() < 2 {
-        expr = syn::parse_quote!( #expr::uumain );
-    };
-    proc_dbg!(&expr);
-
-    let f = quote::quote! { #expr(uucore::args_os()) };
-    proc_dbg!(&f);
-
-    // generate a uutils utility `main()` function, tailored for the calling utility
-    let result = quote::quote! {
-        fn main() {
-            use std::io::Write;
-            uucore::panic::mute_sigpipe_panic(); // suppress extraneous error output for SIGPIPE failures/panics
-            let code = #f; // 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>
-            std::process::exit(code);
-        }
-    };
-    TokenStream::from(result)
-}
-
 #[proc_macro_attribute]
-pub fn gen_uumain(_args: TokenStream, stream: TokenStream) -> TokenStream {
-    let mut ast = parse_macro_input!(stream as ItemFn);
-
-    // Change the name of the function to "uumain_result" to prevent name-conflicts
-    ast.sig.ident = Ident::new("uumain_result", Span::call_site());
+pub fn main(_args: TokenStream, stream: TokenStream) -> TokenStream {
+    let stream = proc_macro2::TokenStream::from(stream);
 
     let new = quote!(
         pub fn uumain(args: impl uucore::Args) -> i32 {
-            #ast
-            let result = uumain_result(args);
+            #stream
+            let result = uumain(args);
             match result {
                 Ok(()) => uucore::error::get_exit_code(),
                 Err(e) => {
diff --git a/tests/benches/factor/Cargo.toml b/tests/benches/factor/Cargo.toml
index b3b718477..eb3d69105 100644
--- a/tests/benches/factor/Cargo.toml
+++ b/tests/benches/factor/Cargo.toml
@@ -13,10 +13,9 @@ uu_factor = { path = "../../../src/uu/factor" }
 [dev-dependencies]
 array-init = "2.0.0"
 criterion = "0.3"
-rand = "0.7"
+rand = "0.8"
 rand_chacha = "0.2.2"
 
-
 [[bench]]
 name = "gcd"
 harness = false
diff --git a/tests/by-util/test_base32.rs b/tests/by-util/test_base32.rs
index ffe2cf74c..0eceb4a66 100644
--- a/tests/by-util/test_base32.rs
+++ b/tests/by-util/test_base32.rs
@@ -34,7 +34,7 @@ fn test_base32_encode_file() {
 
 #[test]
 fn test_decode() {
-    for decode_param in &["-d", "--decode"] {
+    for decode_param in &["-d", "--decode", "--dec"] {
         let input = "JBSWY3DPFQQFO33SNRSCC===\n"; // spell-checker:disable-line
         new_ucmd!()
             .arg(decode_param)
@@ -56,7 +56,7 @@ fn test_garbage() {
 
 #[test]
 fn test_ignore_garbage() {
-    for ignore_garbage_param in &["-i", "--ignore-garbage"] {
+    for ignore_garbage_param in &["-i", "--ignore-garbage", "--ig"] {
         let input = "JBSWY\x013DPFQ\x02QFO33SNRSCC===\n"; // spell-checker:disable-line
         new_ucmd!()
             .arg("-d")
@@ -69,7 +69,7 @@ fn test_ignore_garbage() {
 
 #[test]
 fn test_wrap() {
-    for wrap_param in &["-w", "--wrap"] {
+    for wrap_param in &["-w", "--wrap", "--wr"] {
         let input = "The quick brown fox jumps over the lazy dog.";
         new_ucmd!()
             .arg(wrap_param)
@@ -113,18 +113,12 @@ fn test_wrap_bad_arg() {
 
 #[test]
 fn test_base32_extra_operand() {
-    let ts = TestScenario::new(util_name!());
-
     // Expect a failure when multiple files are specified.
-    ts.ucmd()
+    new_ucmd!()
         .arg("a.txt")
         .arg("b.txt")
         .fails()
-        .stderr_only(format!(
-            "{0}: extra operand 'b.txt'\nTry '{1} {0} --help' for more information.",
-            ts.util_name,
-            ts.bin_path.to_string_lossy()
-        ));
+        .usage_error("extra operand 'b.txt'");
 }
 
 #[test]
diff --git a/tests/by-util/test_base64.rs b/tests/by-util/test_base64.rs
index 87aa0db44..a4b461f91 100644
--- a/tests/by-util/test_base64.rs
+++ b/tests/by-util/test_base64.rs
@@ -26,7 +26,7 @@ fn test_base64_encode_file() {
 
 #[test]
 fn test_decode() {
-    for decode_param in &["-d", "--decode"] {
+    for decode_param in &["-d", "--decode", "--dec"] {
         let input = "aGVsbG8sIHdvcmxkIQ=="; // spell-checker:disable-line
         new_ucmd!()
             .arg(decode_param)
@@ -48,7 +48,7 @@ fn test_garbage() {
 
 #[test]
 fn test_ignore_garbage() {
-    for ignore_garbage_param in &["-i", "--ignore-garbage"] {
+    for ignore_garbage_param in &["-i", "--ignore-garbage", "--ig"] {
         let input = "aGVsbG8sIHdvcmxkIQ==\0"; // spell-checker:disable-line
         new_ucmd!()
             .arg("-d")
@@ -61,7 +61,7 @@ fn test_ignore_garbage() {
 
 #[test]
 fn test_wrap() {
-    for wrap_param in &["-w", "--wrap"] {
+    for wrap_param in &["-w", "--wrap", "--wr"] {
         let input = "The quick brown fox jumps over the lazy dog.";
         new_ucmd!()
             .arg(wrap_param)
@@ -95,18 +95,12 @@ fn test_wrap_bad_arg() {
 
 #[test]
 fn test_base64_extra_operand() {
-    let ts = TestScenario::new(util_name!());
-
     // Expect a failure when multiple files are specified.
-    ts.ucmd()
+    new_ucmd!()
         .arg("a.txt")
         .arg("b.txt")
         .fails()
-        .stderr_only(format!(
-            "{0}: extra operand 'b.txt'\nTry '{1} {0} --help' for more information.",
-            ts.util_name,
-            ts.bin_path.to_string_lossy()
-        ));
+        .usage_error("extra operand 'b.txt'");
 }
 
 #[test]
diff --git a/tests/by-util/test_basename.rs b/tests/by-util/test_basename.rs
index 141745ac3..1250ba76f 100644
--- a/tests/by-util/test_basename.rs
+++ b/tests/by-util/test_basename.rs
@@ -61,7 +61,7 @@ fn test_do_not_remove_suffix() {
 
 #[test]
 fn test_multiple_param() {
-    for &multiple_param in &["-a", "--multiple"] {
+    for &multiple_param in &["-a", "--multiple", "--mul"] {
         let path = "/foo/bar/baz";
         new_ucmd!()
             .args(&[multiple_param, path, path])
@@ -72,7 +72,7 @@ fn test_multiple_param() {
 
 #[test]
 fn test_suffix_param() {
-    for &suffix_param in &["-s", "--suffix"] {
+    for &suffix_param in &["-s", "--suffix", "--suf"] {
         let path = "/foo/bar/baz.exe";
         new_ucmd!()
             .args(&[suffix_param, ".exe", path, path])
@@ -83,7 +83,7 @@ fn test_suffix_param() {
 
 #[test]
 fn test_zero_param() {
-    for &zero_param in &["-z", "--zero"] {
+    for &zero_param in &["-z", "--zero", "--ze"] {
         let path = "/foo/bar/baz";
         new_ucmd!()
             .args(&[zero_param, "-a", path, path])
@@ -92,9 +92,9 @@ fn test_zero_param() {
     }
 }
 
-fn expect_error(input: Vec<&str>) {
+fn expect_error(input: &[&str]) {
     assert!(!new_ucmd!()
-        .args(&input)
+        .args(input)
         .fails()
         .no_stdout()
         .stderr_str()
@@ -104,37 +104,30 @@ fn expect_error(input: Vec<&str>) {
 #[test]
 fn test_invalid_option() {
     let path = "/foo/bar/baz";
-    expect_error(vec!["-q", path]);
+    expect_error(&["-q", path]);
 }
 
 #[test]
 fn test_no_args() {
-    expect_error(vec![]);
+    expect_error(&[]);
 }
 
 #[test]
 fn test_no_args_output() {
-    let ts = TestScenario::new(util_name!());
-    ts.ucmd().fails().stderr_is(&format!(
-        "{0}: missing operand\nTry '{1} {0} --help' for more information.",
-        ts.util_name,
-        ts.bin_path.to_string_lossy()
-    ));
+    new_ucmd!().fails().usage_error("missing operand");
 }
 
 #[test]
 fn test_too_many_args() {
-    expect_error(vec!["a", "b", "c"]);
+    expect_error(&["a", "b", "c"]);
 }
 
 #[test]
 fn test_too_many_args_output() {
-    let ts = TestScenario::new(util_name!());
-    ts.ucmd().args(&["a", "b", "c"]).fails().stderr_is(format!(
-        "{0}: extra operand 'c'\nTry '{1} {0} --help' for more information.",
-        ts.util_name,
-        ts.bin_path.to_string_lossy()
-    ));
+    new_ucmd!()
+        .args(&["a", "b", "c"])
+        .fails()
+        .usage_error("extra operand 'c'");
 }
 
 #[cfg(any(unix, target_os = "redox"))]
diff --git a/tests/by-util/test_cat.rs b/tests/by-util/test_cat.rs
index b629a06e6..64a511656 100644
--- a/tests/by-util/test_cat.rs
+++ b/tests/by-util/test_cat.rs
@@ -172,7 +172,7 @@ fn test_piped_to_dev_full() {
                 .set_stdout(dev_full)
                 .pipe_in_fixture("alpha.txt")
                 .fails()
-                .stderr_contains(&"No space left on device".to_owned());
+                .stderr_contains("No space left on device");
         }
     }
 }
@@ -264,7 +264,7 @@ fn test_numbered_lines_no_trailing_newline() {
 
 #[test]
 fn test_stdin_show_nonprinting() {
-    for same_param in &["-v", "--show-nonprinting"] {
+    for same_param in &["-v", "--show-nonprinting", "--show-non"] {
         new_ucmd!()
             .args(&[same_param])
             .pipe_in("\t\0\n")
@@ -275,7 +275,7 @@ fn test_stdin_show_nonprinting() {
 
 #[test]
 fn test_stdin_show_tabs() {
-    for same_param in &["-T", "--show-tabs"] {
+    for same_param in &["-T", "--show-tabs", "--show-ta"] {
         new_ucmd!()
             .args(&[same_param])
             .pipe_in("\t\0\n")
@@ -286,7 +286,7 @@ fn test_stdin_show_tabs() {
 
 #[test]
 fn test_stdin_show_ends() {
-    for &same_param in &["-E", "--show-ends"] {
+    for &same_param in &["-E", "--show-ends", "--show-e"] {
         new_ucmd!()
             .args(&[same_param, "-"])
             .pipe_in("\t\0\n\t")
@@ -317,7 +317,7 @@ fn test_show_ends_crlf() {
 
 #[test]
 fn test_stdin_show_all() {
-    for same_param in &["-A", "--show-all"] {
+    for same_param in &["-A", "--show-all", "--show-a"] {
         new_ucmd!()
             .args(&[same_param])
             .pipe_in("\t\0\n")
@@ -346,7 +346,7 @@ fn test_stdin_nonprinting_and_tabs() {
 
 #[test]
 fn test_stdin_squeeze_blank() {
-    for same_param in &["-s", "--squeeze-blank"] {
+    for same_param in &["-s", "--squeeze-blank", "--squeeze"] {
         new_ucmd!()
             .arg(same_param)
             .pipe_in("\n\na\n\n\n\n\nb\n\n\n")
@@ -358,7 +358,7 @@ fn test_stdin_squeeze_blank() {
 #[test]
 fn test_stdin_number_non_blank() {
     // spell-checker:disable-next-line
-    for same_param in &["-b", "--number-nonblank"] {
+    for same_param in &["-b", "--number-nonblank", "--number-non"] {
         new_ucmd!()
             .arg(same_param)
             .arg("-")
diff --git a/tests/by-util/test_chcon.rs b/tests/by-util/test_chcon.rs
index 2bdc512d5..82dab9ae3 100644
--- a/tests/by-util/test_chcon.rs
+++ b/tests/by-util/test_chcon.rs
@@ -461,9 +461,9 @@ fn set_file_context(path: impl AsRef<Path>, context: &str) -> Result<(), selinux
             context,
             path.display(),
             r
-        )
+        );
     } else {
-        println!("set_file_context: '{}' => '{}'.", context, path.display())
+        println!("set_file_context: '{}' => '{}'.", context, path.display());
     }
     r
 }
diff --git a/tests/by-util/test_chgrp.rs b/tests/by-util/test_chgrp.rs
index 1d047cfe2..6c0aa46ad 100644
--- a/tests/by-util/test_chgrp.rs
+++ b/tests/by-util/test_chgrp.rs
@@ -60,7 +60,7 @@ fn test_1() {
 #[test]
 fn test_fail_silently() {
     if get_effective_gid() != 0 {
-        for opt in &["-f", "--silent", "--quiet"] {
+        for opt in &["-f", "--silent", "--quiet", "--sil", "--qui"] {
             new_ucmd!()
                 .arg(opt)
                 .arg("bin")
diff --git a/tests/by-util/test_chmod.rs b/tests/by-util/test_chmod.rs
index c8348d491..373ad97ce 100644
--- a/tests/by-util/test_chmod.rs
+++ b/tests/by-util/test_chmod.rs
@@ -33,7 +33,7 @@ fn make_file(file: &str, mode: u32) {
     set_permissions(file, perms).unwrap();
 }
 
-fn run_single_test(test: &TestCase, at: AtPath, mut ucmd: UCommand) {
+fn run_single_test(test: &TestCase, at: &AtPath, mut ucmd: UCommand) {
     make_file(&at.plus_as_string(TEST_FILE), test.before);
     let perms = at.metadata(TEST_FILE).permissions().mode();
     if perms != test.before {
@@ -64,7 +64,7 @@ fn run_single_test(test: &TestCase, at: AtPath, mut ucmd: UCommand) {
 fn run_tests(tests: Vec<TestCase>) {
     for test in tests {
         let (at, ucmd) = at_and_ucmd!();
-        run_single_test(&test, at, ucmd);
+        run_single_test(&test, &at, ucmd);
     }
 }
 
@@ -295,7 +295,7 @@ fn test_chmod_reference_file() {
     ];
     let (at, ucmd) = at_and_ucmd!();
     make_file(&at.plus_as_string(REFERENCE_FILE), REFERENCE_PERMS);
-    run_single_test(&tests[0], at, ucmd);
+    run_single_test(&tests[0], &at, ucmd);
 }
 
 #[test]
@@ -334,19 +334,20 @@ fn test_chmod_recursive() {
     make_file(&at.plus_as_string("a/b/c/c"), 0o100444);
     make_file(&at.plus_as_string("z/y"), 0o100444);
 
+    // only the permissions of folder `a` and `z` are changed
+    // folder can't be read after read permission is removed
     ucmd.arg("-R")
         .arg("--verbose")
         .arg("-r,a+w")
         .arg("a")
         .arg("z")
-        .succeeds()
-        .stdout_contains(&"to 0333 (-wx-wx-wx)")
-        .stdout_contains(&"to 0222 (-w--w--w-)");
+        .fails()
+        .stderr_is("chmod: Permission denied");
 
-    assert_eq!(at.metadata("z/y").permissions().mode(), 0o100222);
-    assert_eq!(at.metadata("a/a").permissions().mode(), 0o100222);
-    assert_eq!(at.metadata("a/b/b").permissions().mode(), 0o100222);
-    assert_eq!(at.metadata("a/b/c/c").permissions().mode(), 0o100222);
+    assert_eq!(at.metadata("z/y").permissions().mode(), 0o100444);
+    assert_eq!(at.metadata("a/a").permissions().mode(), 0o100444);
+    assert_eq!(at.metadata("a/b/b").permissions().mode(), 0o100444);
+    assert_eq!(at.metadata("a/b/c/c").permissions().mode(), 0o100444);
     println!("mode {:o}", at.metadata("a").permissions().mode());
     assert_eq!(at.metadata("a").permissions().mode(), 0o40333);
     assert_eq!(at.metadata("z").permissions().mode(), 0o40333);
@@ -356,6 +357,23 @@ fn test_chmod_recursive() {
     }
 }
 
+#[test]
+#[allow(clippy::unreadable_literal)]
+fn test_chmod_recursive_read_permission() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("a");
+    at.mkdir("a/b");
+    let mut perms = at.metadata("a/b").permissions();
+    perms.set_mode(0o311);
+    set_permissions(at.plus_as_string("a/b"), perms.clone()).unwrap();
+    set_permissions(at.plus_as_string("a"), perms).unwrap();
+
+    ucmd.arg("-R").arg("u+r").arg("a").succeeds();
+
+    assert_eq!(at.metadata("a").permissions().mode(), 0o40711);
+    assert_eq!(at.metadata("a/b").permissions().mode(), 0o40711);
+}
+
 #[test]
 fn test_chmod_non_existing_file() {
     new_ucmd!()
@@ -455,8 +473,8 @@ fn test_chmod_symlink_non_existing_file_recursive() {
 
     let expected_stdout = &format!(
         // spell-checker:disable-next-line
-        "mode of '{}' retained as 0755 (rwxr-xr-x)\nneither symbolic link '{}/{}' nor referent has been changed",
-        test_directory, test_directory, test_symlink
+        "mode of '{}' retained as 0755 (rwxr-xr-x)",
+        test_directory
     );
 
     // '-v': this should succeed without stderr
@@ -541,7 +559,7 @@ fn test_no_operands() {
         .arg("777")
         .fails()
         .code_is(1)
-        .stderr_is("chmod: missing operand");
+        .usage_error("missing operand");
 }
 
 #[test]
@@ -553,7 +571,7 @@ fn test_mode_after_dash_dash() {
             before: 0o100777,
             after: 0o100333,
         },
-        at,
+        &at,
         ucmd,
     );
 }
diff --git a/tests/by-util/test_chown.rs b/tests/by-util/test_chown.rs
index d5ebb4600..0857e5659 100644
--- a/tests/by-util/test_chown.rs
+++ b/tests/by-util/test_chown.rs
@@ -48,7 +48,7 @@ mod test_passgrp {
     #[test]
     fn test_grp2gid() {
         if cfg!(target_os = "linux") || cfg!(target_os = "android") || cfg!(target_os = "windows") {
-            assert_eq!(0, grp2gid("root").unwrap())
+            assert_eq!(0, grp2gid("root").unwrap());
         } else {
             assert_eq!(0, grp2gid("wheel").unwrap());
         }
diff --git a/tests/by-util/test_cksum.rs b/tests/by-util/test_cksum.rs
index bf31ceb18..66bdba9e3 100644
--- a/tests/by-util/test_cksum.rs
+++ b/tests/by-util/test_cksum.rs
@@ -74,9 +74,8 @@ fn test_invalid_file() {
     at.mkdir(folder_name);
     ts.ucmd()
         .arg(folder_name)
-        .fails()
-        .no_stdout()
-        .stderr_contains("cksum: asdf: Is a directory");
+        .succeeds()
+        .stdout_only("4294967295 0 asdf\n");
 }
 
 // Make sure crc is correct for files larger than 32 bytes
diff --git a/tests/by-util/test_comm.rs b/tests/by-util/test_comm.rs
index 01cdcc985..d5b72b1e9 100644
--- a/tests/by-util/test_comm.rs
+++ b/tests/by-util/test_comm.rs
@@ -170,3 +170,11 @@ fn no_arguments() {
 fn one_argument() {
     new_ucmd!().arg("a").fails().no_stdout().no_stderr();
 }
+
+#[test]
+fn test_no_such_file() {
+    new_ucmd!()
+        .args(&["bogus_file_1", "bogus_file_2"])
+        .fails()
+        .stderr_only("comm: bogus_file_1: No such file or directory");
+}
diff --git a/tests/by-util/test_cp.rs b/tests/by-util/test_cp.rs
index e86f35833..11afa469e 100644
--- a/tests/by-util/test_cp.rs
+++ b/tests/by-util/test_cp.rs
@@ -1,4 +1,4 @@
-// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE
+// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob
 
 use crate::common::util::*;
 #[cfg(not(windows))]
@@ -29,6 +29,7 @@ static TEST_EXISTING_FILE: &str = "existing_file.txt";
 static TEST_HELLO_WORLD_SOURCE: &str = "hello_world.txt";
 static TEST_HELLO_WORLD_SOURCE_SYMLINK: &str = "hello_world.txt.link";
 static TEST_HELLO_WORLD_DEST: &str = "copy_of_hello_world.txt";
+static TEST_HELLO_WORLD_DEST_SYMLINK: &str = "copy_of_hello_world.txt.link";
 static TEST_HOW_ARE_YOU_SOURCE: &str = "how_are_you.txt";
 static TEST_HOW_ARE_YOU_DEST: &str = "hello_dir/how_are_you.txt";
 static TEST_COPY_TO_FOLDER: &str = "hello_dir/";
@@ -43,6 +44,8 @@ static TEST_MOUNT_COPY_FROM_FOLDER: &str = "dir_with_mount";
 static TEST_MOUNT_MOUNTPOINT: &str = "mount";
 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
 static TEST_MOUNT_OTHER_FILESYSTEM_FILE: &str = "mount/DO_NOT_copy_me.txt";
+#[cfg(unix)]
+static TEST_NONEXISTENT_FILE: &str = "nonexistent_file.txt";
 
 #[test]
 fn test_cp_cp() {
@@ -180,6 +183,16 @@ fn test_cp_arg_no_target_directory() {
         .stderr_contains("cannot overwrite directory");
 }
 
+#[test]
+fn test_cp_target_directory_is_file() {
+    new_ucmd!()
+        .arg("-t")
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .fails()
+        .stderr_contains(format!("'{}' is not a directory", TEST_HOW_ARE_YOU_SOURCE));
+}
+
 #[test]
 fn test_cp_arg_interactive() {
     new_ucmd!()
@@ -227,6 +240,17 @@ fn test_cp_arg_no_clobber() {
     assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
 }
 
+#[test]
+fn test_cp_arg_no_clobber_inferred_arg() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg("--no-clob")
+        .succeeds();
+
+    assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
+}
+
 #[test]
 fn test_cp_arg_no_clobber_twice() {
     let scene = TestScenario::new(util_name!());
@@ -372,6 +396,24 @@ fn test_cp_arg_suffix() {
     );
 }
 
+#[test]
+fn test_cp_arg_suffix_hyphen_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("-b")
+        .arg("--suffix")
+        .arg("-v")
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .succeeds();
+
+    assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "Hello, World!\n");
+    assert_eq!(
+        at.read(&*format!("{}-v", TEST_HOW_ARE_YOU_SOURCE)),
+        "How are you?\n"
+    );
+}
+
 #[test]
 fn test_cp_custom_backup_suffix_via_env() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -563,17 +605,13 @@ fn test_cp_backup_off() {
 
 #[test]
 fn test_cp_backup_no_clobber_conflicting_options() {
-    let ts = TestScenario::new(util_name!());
-    ts.ucmd()
+    new_ucmd!()
         .arg("--backup")
         .arg("--no-clobber")
         .arg(TEST_HELLO_WORLD_SOURCE)
         .arg(TEST_HOW_ARE_YOU_SOURCE)
-        .fails().stderr_is(&format!(
-            "{0}: options --backup and --no-clobber are mutually exclusive\nTry '{1} {0} --help' for more information.",
-            ts.util_name,
-            ts.bin_path.to_string_lossy()
-        ));
+        .fails()
+        .usage_error("options --backup and --no-clobber are mutually exclusive");
 }
 
 #[test]
@@ -661,6 +699,51 @@ fn test_cp_no_deref() {
     assert_eq!(at.read(path_to_check), "Hello, World!\n");
 }
 
+#[test]
+fn test_cp_no_deref_link_onto_link() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.copy(TEST_HELLO_WORLD_SOURCE, TEST_HELLO_WORLD_DEST);
+
+    #[cfg(not(windows))]
+    let _r = fs::symlink(
+        TEST_HELLO_WORLD_SOURCE,
+        at.subdir.join(TEST_HELLO_WORLD_SOURCE_SYMLINK),
+    );
+    #[cfg(windows)]
+    let _r = symlink_file(
+        TEST_HELLO_WORLD_SOURCE,
+        at.subdir.join(TEST_HELLO_WORLD_SOURCE_SYMLINK),
+    );
+
+    #[cfg(not(windows))]
+    let _r = fs::symlink(
+        TEST_HELLO_WORLD_DEST,
+        at.subdir.join(TEST_HELLO_WORLD_DEST_SYMLINK),
+    );
+    #[cfg(windows)]
+    let _r = symlink_file(
+        TEST_HELLO_WORLD_DEST,
+        at.subdir.join(TEST_HELLO_WORLD_DEST_SYMLINK),
+    );
+
+    ucmd.arg("-P")
+        .arg(TEST_HELLO_WORLD_SOURCE_SYMLINK)
+        .arg(TEST_HELLO_WORLD_DEST_SYMLINK)
+        .succeeds();
+
+    // Ensure that the target of the destination was not modified.
+    assert!(!at
+        .symlink_metadata(TEST_HELLO_WORLD_DEST)
+        .file_type()
+        .is_symlink());
+    assert!(at
+        .symlink_metadata(TEST_HELLO_WORLD_DEST_SYMLINK)
+        .file_type()
+        .is_symlink());
+    assert_eq!(at.read(TEST_HELLO_WORLD_DEST_SYMLINK), "Hello, World!\n");
+}
+
 #[test]
 fn test_cp_strip_trailing_slashes() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -729,6 +812,21 @@ fn test_cp_parents_dest_not_directory() {
         .stderr_contains("with --parents, the destination must be a directory");
 }
 
+#[test]
+#[cfg(unix)]
+fn test_cp_writable_special_file_permissions() {
+    new_ucmd!().arg("/dev/null").arg("/dev/zero").succeeds();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_issue_1665() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg("/dev/null").arg("foo").succeeds();
+    assert!(at.file_exists("foo"));
+    assert_eq!(at.read("foo"), "");
+}
+
 #[test]
 fn test_cp_preserve_no_args() {
     new_ucmd!()
@@ -1368,3 +1466,163 @@ fn test_canonicalize_symlink() {
         .no_stderr()
         .no_stdout();
 }
+
+#[test]
+fn test_copy_through_just_created_symlink() {
+    for &create_t in &[true, false] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        at.mkdir("a");
+        at.mkdir("b");
+        at.mkdir("c");
+        #[cfg(unix)]
+        fs::symlink("../t", at.plus("a/1")).unwrap();
+        #[cfg(target_os = "windows")]
+        symlink_file("../t", at.plus("a/1")).unwrap();
+        at.touch("b/1");
+        if create_t {
+            at.touch("t");
+        }
+        ucmd.arg("--no-dereference")
+            .arg("a/1")
+            .arg("b/1")
+            .arg("c")
+            .fails()
+            .stderr_only(if cfg!(not(target_os = "windows")) {
+                "cp: will not copy 'b/1' through just-created symlink 'c/1'"
+            } else {
+                "cp: will not copy 'b/1' through just-created symlink 'c\\1'"
+            });
+    }
+}
+
+#[test]
+fn test_copy_through_dangling_symlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("file");
+    at.symlink_file("nonexistent", "target");
+    ucmd.arg("file")
+        .arg("target")
+        .fails()
+        .stderr_only("cp: not writing through dangling symlink 'target'");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_archive_on_nonexistent_file() {
+    new_ucmd!()
+        .arg("-a")
+        .arg(TEST_NONEXISTENT_FILE)
+        .arg(TEST_EXISTING_FILE)
+        .fails()
+        .stderr_only(
+            "cp: cannot stat 'nonexistent_file.txt': No such file or directory (os error 2)",
+        );
+}
+
+#[test]
+fn test_cp_link_backup() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("file2");
+    ucmd.arg("-l")
+        .arg("-b")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("file2")
+        .succeeds();
+
+    assert!(at.file_exists("file2~"));
+    assert_eq!(at.read("file2"), "Hello, World!\n");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_fifo() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkfifo("fifo");
+    ucmd.arg("-r")
+        .arg("fifo")
+        .arg("fifo2")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    assert!(at.is_fifo("fifo2"));
+}
+
+#[test]
+fn test_dir_recursive_copy() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("parent1");
+    at.mkdir("parent2");
+    at.mkdir("parent1/child");
+    at.mkdir("parent2/child1");
+    at.mkdir("parent2/child1/child2");
+    at.mkdir("parent2/child1/child2/child3");
+
+    // case-1: copy parent1 -> parent1: should fail
+    scene
+        .ucmd()
+        .arg("-R")
+        .arg("parent1")
+        .arg("parent1")
+        .fails()
+        .stderr_contains("cannot copy a directory");
+    // case-2: copy parent1 -> parent1/child should fail
+    scene
+        .ucmd()
+        .arg("-R")
+        .arg("parent1")
+        .arg("parent1/child")
+        .fails()
+        .stderr_contains("cannot copy a directory");
+    // case-3: copy parent1/child -> parent2 should pass
+    scene
+        .ucmd()
+        .arg("-R")
+        .arg("parent1/child")
+        .arg("parent2")
+        .succeeds();
+    // case-4: copy parent2/child1/ -> parent2/child1/child2/child3
+    scene
+        .ucmd()
+        .arg("-R")
+        .arg("parent2/child1/")
+        .arg("parent2/child1/child2/child3")
+        .fails()
+        .stderr_contains("cannot copy a directory");
+}
+
+#[test]
+fn test_cp_dir_vs_file() {
+    new_ucmd!()
+        .arg("-R")
+        .arg(TEST_COPY_FROM_FOLDER)
+        .arg(TEST_EXISTING_FILE)
+        .fails()
+        .stderr_only("cp: cannot overwrite non-directory with directory");
+}
+
+#[test]
+fn test_cp_overriding_arguments() {
+    let s = TestScenario::new(util_name!());
+    s.fixtures.touch("file1");
+    for (arg1, arg2) in &[
+        #[cfg(not(windows))]
+        ("--remove-destination", "--force"),
+        #[cfg(not(windows))]
+        ("--force", "--remove-destination"),
+        ("--interactive", "--no-clobber"),
+        ("--link", "--symbolic-link"),
+        ("--symbolic-link", "--link"),
+        ("--dereference", "--no-dereference"),
+        ("--no-dereference", "--dereference"),
+    ] {
+        s.ucmd()
+            .arg(arg1)
+            .arg(arg2)
+            .arg("file1")
+            .arg("file2")
+            .succeeds();
+        s.fixtures.remove("file2");
+    }
+}
diff --git a/tests/by-util/test_cut.rs b/tests/by-util/test_cut.rs
index 92bab4d75..da707ac3a 100644
--- a/tests/by-util/test_cut.rs
+++ b/tests/by-util/test_cut.rs
@@ -41,7 +41,7 @@ static COMPLEX_SEQUENCE: &TestedSequence = &TestedSequence {
 
 #[test]
 fn test_byte_sequence() {
-    for &param in &["-b", "--bytes"] {
+    for &param in &["-b", "--bytes", "--byt"] {
         for example_seq in EXAMPLE_SEQUENCES {
             new_ucmd!()
                 .args(&[param, example_seq.sequence, INPUT])
@@ -53,7 +53,7 @@ fn test_byte_sequence() {
 
 #[test]
 fn test_char_sequence() {
-    for &param in &["-c", "--characters"] {
+    for &param in &["-c", "--characters", "--char"] {
         for example_seq in EXAMPLE_SEQUENCES {
             //as of coreutils 8.25 a char range is effectively the same as a byte range; there is no distinct treatment of utf8 chars.
             new_ucmd!()
@@ -66,7 +66,7 @@ fn test_char_sequence() {
 
 #[test]
 fn test_field_sequence() {
-    for &param in &["-f", "--fields"] {
+    for &param in &["-f", "--fields", "--fie"] {
         for example_seq in EXAMPLE_SEQUENCES {
             new_ucmd!()
                 .args(&[param, example_seq.sequence, INPUT])
@@ -78,7 +78,7 @@ fn test_field_sequence() {
 
 #[test]
 fn test_specify_delimiter() {
-    for &param in &["-d", "--delimiter"] {
+    for &param in &["-d", "--delimiter", "--del"] {
         new_ucmd!()
             .args(&[param, ":", "-f", COMPLEX_SEQUENCE.sequence, INPUT])
             .succeeds()
@@ -100,29 +100,42 @@ fn test_output_delimiter() {
         ])
         .succeeds()
         .stdout_only_fixture("output_delimiter.expected");
+
+    new_ucmd!()
+        .args(&[
+            "-d:",
+            "--output-del=@",
+            "-f",
+            COMPLEX_SEQUENCE.sequence,
+            INPUT,
+        ])
+        .succeeds()
+        .stdout_only_fixture("output_delimiter.expected");
 }
 
 #[test]
 fn test_complement() {
-    new_ucmd!()
-        .args(&["-d_", "--complement", "-f", "2"])
-        .pipe_in("9_1\n8_2\n7_3")
-        .succeeds()
-        .stdout_only("9\n8\n7\n");
+    for param in &["--complement", "--com"] {
+        new_ucmd!()
+            .args(&["-d_", param, "-f", "2"])
+            .pipe_in("9_1\n8_2\n7_3")
+            .succeeds()
+            .stdout_only("9\n8\n7\n");
+    }
 }
 
 #[test]
 fn test_zero_terminated() {
     new_ucmd!()
         .args(&["-d_", "-z", "-f", "1"])
-        .pipe_in("9_1\n8_2\n\07_3")
+        .pipe_in("9_1\n8_2\n\x007_3")
         .succeeds()
-        .stdout_only("9\07\0");
+        .stdout_only("9\x007\0");
 }
 
 #[test]
 fn test_only_delimited() {
-    for param in &["-s", "--only-delimited"] {
+    for param in &["-s", "--only-delimited", "--only-del"] {
         new_ucmd!()
             .args(&["-d_", param, "-f", "1"])
             .pipe_in("91\n82\n7_3")
diff --git a/tests/by-util/test_date.rs b/tests/by-util/test_date.rs
index a7a5fa583..05c6f89db 100644
--- a/tests/by-util/test_date.rs
+++ b/tests/by-util/test_date.rs
@@ -7,12 +7,9 @@ use rust_users::*;
 
 #[test]
 fn test_date_email() {
-    new_ucmd!().arg("--rfc-email").succeeds();
-}
-
-#[test]
-fn test_date_email2() {
-    new_ucmd!().arg("-R").succeeds();
+    for param in &["--rfc-email", "--rfc-e", "-R"] {
+        new_ucmd!().arg(param).succeeds();
+    }
 }
 
 #[test]
@@ -26,37 +23,40 @@ fn test_date_rfc_3339() {
     let re = Regex::new(rfc_regexp).unwrap();
 
     // Check that the output matches the regexp
-    scene
-        .ucmd()
-        .arg("--rfc-3339=ns")
-        .succeeds()
-        .stdout_matches(&re);
+    for param in &["--rfc-3339", "--rfc-3"] {
+        scene
+            .ucmd()
+            .arg(format!("{}=ns", param))
+            .succeeds()
+            .stdout_matches(&re);
 
-    scene
-        .ucmd()
-        .arg("--rfc-3339=seconds")
-        .succeeds()
-        .stdout_matches(&re);
+        scene
+            .ucmd()
+            .arg(format!("{}=seconds", param))
+            .succeeds()
+            .stdout_matches(&re);
+    }
 }
 
 #[test]
 fn test_date_rfc_8601() {
-    new_ucmd!().arg("--iso-8601=ns").succeeds();
+    for param in &["--iso-8601", "--i"] {
+        new_ucmd!().arg(format!("{}=ns", param)).succeeds();
+    }
 }
 
 #[test]
 fn test_date_rfc_8601_second() {
-    new_ucmd!().arg("--iso-8601=second").succeeds();
+    for param in &["--iso-8601", "--i"] {
+        new_ucmd!().arg(format!("{}=second", param)).succeeds();
+    }
 }
 
 #[test]
 fn test_date_utc() {
-    new_ucmd!().arg("--utc").succeeds();
-}
-
-#[test]
-fn test_date_universal() {
-    new_ucmd!().arg("--universal").succeeds();
+    for param in &["--universal", "--utc", "--uni", "--u"] {
+        new_ucmd!().arg(param).succeeds();
+    }
 }
 
 #[test]
diff --git a/tests/by-util/test_dd.rs b/tests/by-util/test_dd.rs
index 8340c7059..f6287a940 100644
--- a/tests/by-util/test_dd.rs
+++ b/tests/by-util/test_dd.rs
@@ -1,4 +1,4 @@
-// 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, nocache, noctty, noerror, nofollow, nolinks, nonblock, oconvflags, outfile, parseargs, rlen, rmax, rposition, rremain, rsofar, rstat, sigusr, sigval, wlen, wstat
+// 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
 
 use crate::common::util::*;
 
@@ -178,12 +178,72 @@ fn test_stdin_stdout_count_w_multiplier() {
         .success();
 }
 
+#[test]
+fn test_b_multiplier() {
+    // "2b" means 2 * 512, which is 1024.
+    new_ucmd!()
+        .args(&["bs=2b", "count=1"])
+        .pipe_in("a".repeat(1025))
+        .succeeds()
+        .stdout_is("a".repeat(1024));
+}
+
+#[test]
+fn test_x_multiplier() {
+    // "2x3" means 2 * 3, which is 6.
+    new_ucmd!()
+        .args(&["bs=2x3", "count=1"])
+        .pipe_in("abcdefghi")
+        .succeeds()
+        .stdout_is("abcdef");
+}
+
+#[test]
+fn test_zero_multiplier_warning() {
+    for arg in ["count", "seek", "skip"] {
+        new_ucmd!()
+            .args(&[format!("{}=0", arg).as_str(), "status=none"])
+            .pipe_in("")
+            .succeeds()
+            .no_stdout()
+            .no_stderr();
+
+        new_ucmd!()
+            .args(&[format!("{}=00x1", arg).as_str(), "status=none"])
+            .pipe_in("")
+            .succeeds()
+            .no_stdout()
+            .no_stderr();
+
+        new_ucmd!()
+            .args(&[format!("{}=0x1", arg).as_str(), "status=none"])
+            .pipe_in("")
+            .succeeds()
+            .no_stdout()
+            .stderr_contains("warning: '0x' is a zero multiplier; use '00x' if that is intended");
+
+        new_ucmd!()
+            .args(&[format!("{}=0x0x1", arg).as_str(), "status=none"])
+            .pipe_in("")
+            .succeeds()
+            .no_stdout()
+            .stderr_is("dd: warning: '0x' is a zero multiplier; use '00x' if that is intended\ndd: warning: '0x' is a zero multiplier; use '00x' if that is intended\n");
+
+        new_ucmd!()
+            .args(&[format!("{}=1x0x1", arg).as_str(), "status=none"])
+            .pipe_in("")
+            .succeeds()
+            .no_stdout()
+            .stderr_contains("warning: '0x' is a zero multiplier; use '00x' if that is intended");
+    }
+}
+
 #[test]
 fn test_final_stats_noxfer() {
     new_ucmd!()
         .args(&["status=noxfer"])
         .succeeds()
-        .stderr_only("");
+        .stderr_only("0+0 records in\n0+0 records out\n");
 }
 
 #[test]
@@ -262,7 +322,9 @@ fn test_nocreat_causes_failure_when_outfile_not_present() {
     ucmd.args(&["conv=nocreat", of!(&fname)])
         .pipe_in("")
         .fails()
-        .stderr_is("dd Error: No such file or directory (os error 2)");
+        .stderr_only(
+            "dd: failed to open 'this-file-does-not-exist.txt': No such file or directory",
+        );
     assert!(!fix.file_exists(fname));
 }
 
@@ -357,7 +419,7 @@ fn test_fullblock() {
             of!(&tmp_fn),
             "bs=128M",
             // Note: In order for this test to actually test iflag=fullblock, the bs=VALUE
-            // must be big enough to 'overwhelm' urandom's store of bytes.
+            // must be big enough to 'overwhelm' the urandom store of bytes.
             // Try executing 'dd if=/dev/urandom bs=128M count=1' (i.e without iflag=fullblock).
             // The stats should contain the line: '0+1 records in' indicating a partial read.
             // Since my system only copies 32 MiB without fullblock, I expect 128 MiB to be
@@ -398,6 +460,20 @@ fn test_zeros_to_stdout() {
         .success();
 }
 
+#[cfg(target_pointer_width = "32")]
+#[test]
+fn test_oversized_bs_32_bit() {
+    for bs_param in &["bs", "ibs", "obs", "cbs"] {
+        new_ucmd!()
+            .args(&[format!("{}=5GB", bs_param)])
+            .run()
+            .no_stdout()
+            .failure()
+            .status_code(1)
+            .stderr_is(format!("dd: {}=N cannot fit into memory\n", bs_param));
+    }
+}
+
 #[test]
 fn test_to_stdout_with_ibs_obs() {
     let output: Vec<_> = String::from("y\n").bytes().cycle().take(1024).collect();
@@ -557,5 +633,554 @@ fn test_unicode_filenames() {
     );
 }
 
-// conv=[ascii,ebcdic,ibm], conv=[ucase,lcase], conv=[block,unblock], conv=sync
-// TODO: Move conv tests from unit test module
+#[test]
+fn test_conv_ascii_implies_unblock() {
+    // 0x40 = 0o100 =  64, which gets converted to ' '
+    // 0xc1 = 0o301 = 193, which gets converted to 'A'
+    //
+    // `conv=ascii` implies `conv=unblock`, which means trailing paces
+    // are stripped and a newline is appended at the end of each
+    // block.
+    //
+    // `cbs=4` means use a conversion block size of 4 bytes per block.
+    new_ucmd!()
+        .args(&["conv=ascii", "cbs=4"])
+        .pipe_in(b"\x40\xc1\x40\xc1\x40\xc1\x40\x40".to_vec())
+        .succeeds()
+        .stdout_is(" A A\n A\n");
+}
+
+#[test]
+fn test_conv_ebcdic_implies_block() {
+    // 0x40 = 0o100 =  64, which is the result of converting from ' '
+    // 0xc1 = 0o301 = 193, which is the result of converting from 'A'
+    //
+    // `conv=ebcdic` implies `conv=block`, which means trailing spaces
+    // are added to pad each block.
+    //
+    // `cbs=4` means use a conversion block size of 4 bytes per block.
+    new_ucmd!()
+        .args(&["conv=ebcdic", "cbs=4"])
+        .pipe_in(" A A\n A\n")
+        .succeeds()
+        .stdout_is_bytes(b"\x40\xc1\x40\xc1\x40\xc1\x40\x40");
+}
+
+/// Test for seeking forward N bytes in the output file before copying.
+#[test]
+fn test_seek_bytes() {
+    // Since the output file is stdout, seeking forward by eight bytes
+    // results in a prefix of eight null bytes.
+    new_ucmd!()
+        .args(&["seek=8", "oflag=seek_bytes"])
+        .pipe_in("abcdefghijklm\n")
+        .succeeds()
+        .stdout_is("\0\0\0\0\0\0\0\0abcdefghijklm\n");
+}
+
+/// Test for skipping beyond the number of bytes in a file.
+#[test]
+fn test_skip_beyond_file() {
+    new_ucmd!()
+        .args(&["bs=1", "skip=5", "count=0", "status=noxfer"])
+        .pipe_in("abcd")
+        .succeeds()
+        .no_stdout()
+        .stderr_contains(
+            "'standard input': cannot skip to specified offset\n0+0 records in\n0+0 records out\n",
+        );
+}
+
+#[test]
+fn test_seek_do_not_overwrite() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut outfile = at.make_file("outfile");
+    outfile.write_all(b"abc").unwrap();
+    // Skip the first byte of the input, seek past the first byte of
+    // the output, and write only one byte to the output.
+    ucmd.args(&[
+        "bs=1",
+        "skip=1",
+        "seek=1",
+        "count=1",
+        "status=noxfer",
+        "of=outfile",
+    ])
+    .pipe_in("123")
+    .succeeds()
+    .stderr_is("1+0 records in\n1+0 records out\n")
+    .no_stdout();
+    assert_eq!(at.read("outfile"), "a2");
+}
+
+#[test]
+fn test_partial_records_out() {
+    new_ucmd!()
+        .args(&["bs=2", "status=noxfer"])
+        .pipe_in("abc")
+        .succeeds()
+        .stdout_is("abc")
+        .stderr_is("1+1 records in\n1+1 records out\n");
+}
+
+#[test]
+fn test_block_cbs16() {
+    new_ucmd!()
+        .args(&["conv=block", "cbs=16"])
+        .pipe_in_fixture("dd-block-cbs16.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-block-cbs16.spec");
+}
+
+#[test]
+fn test_block_cbs16_as_cbs8() {
+    new_ucmd!()
+        .args(&["conv=block", "cbs=8"])
+        .pipe_in_fixture("dd-block-cbs16.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-block-cbs8.spec");
+}
+
+#[test]
+fn test_block_consecutive_nl() {
+    new_ucmd!()
+        .args(&["conv=block", "cbs=16"])
+        .pipe_in_fixture("dd-block-consecutive-nl.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-block-consecutive-nl-cbs16.spec");
+}
+
+#[test]
+fn test_unblock_multi_16() {
+    new_ucmd!()
+        .args(&["conv=unblock", "cbs=16"])
+        .pipe_in_fixture("dd-unblock-cbs16.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-unblock-cbs16.spec");
+}
+
+#[test]
+fn test_unblock_multi_16_as_8() {
+    new_ucmd!()
+        .args(&["conv=unblock", "cbs=8"])
+        .pipe_in_fixture("dd-unblock-cbs16.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-unblock-cbs8.spec");
+}
+
+#[test]
+fn test_atoe_conv_spec_test() {
+    new_ucmd!()
+        .args(&["conv=ebcdic"])
+        .pipe_in_fixture("seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-atoe-seq-byte-values.spec");
+}
+
+#[test]
+fn test_etoa_conv_spec_test() {
+    new_ucmd!()
+        .args(&["conv=ascii"])
+        .pipe_in_fixture("seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-etoa-seq-byte-values.spec");
+}
+
+#[test]
+fn test_atoibm_conv_spec_test() {
+    new_ucmd!()
+        .args(&["conv=ibm"])
+        .pipe_in_fixture("seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-atoibm-seq-byte-values.spec");
+}
+
+#[test]
+fn test_lcase_ascii_to_ucase_ascii() {
+    new_ucmd!()
+        .args(&["conv=ucase"])
+        .pipe_in_fixture("lcase-ascii.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("ucase-ascii.test");
+}
+
+#[test]
+fn test_ucase_ascii_to_lcase_ascii() {
+    new_ucmd!()
+        .args(&["conv=lcase"])
+        .pipe_in_fixture("ucase-ascii.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("lcase-ascii.test");
+}
+
+#[test]
+fn test_atoe_and_ucase_conv_spec_test() {
+    new_ucmd!()
+        .args(&["conv=ebcdic,ucase"])
+        .pipe_in_fixture("seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("ucase-ebcdic.test");
+}
+
+#[test]
+fn test_atoe_and_lcase_conv_spec_test() {
+    new_ucmd!()
+        .args(&["conv=ebcdic,lcase"])
+        .pipe_in_fixture("seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("lcase-ebcdic.test");
+}
+
+// TODO I think uppercase and lowercase are unintentionally swapped in
+// the code that parses the command-line arguments. See this line from
+// `parseargs.rs`:
+//
+//     (ConvFlag::FmtAtoI, ConvFlag::UCase) => Some(&ASCII_TO_IBM_UCASE_TO_LCASE),
+//     (ConvFlag::FmtAtoI, ConvFlag::LCase) => Some(&ASCII_TO_IBM_LCASE_TO_UCASE),
+//
+// If my reading is correct and that is a typo, then the
+// UCASE_TO_LCASE and LCASE_TO_UCASE in those lines should be swapped,
+// and the expected output for the following two tests should be
+// updated accordingly.
+#[test]
+fn test_atoibm_and_ucase_conv_spec_test() {
+    new_ucmd!()
+        .args(&["conv=ibm,ucase"])
+        .pipe_in_fixture("seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("lcase-ibm.test");
+}
+
+#[test]
+fn test_atoibm_and_lcase_conv_spec_test() {
+    new_ucmd!()
+        .args(&["conv=ibm,lcase"])
+        .pipe_in_fixture("seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("ucase-ibm.test");
+}
+
+#[test]
+fn test_swab_256_test() {
+    new_ucmd!()
+        .args(&["conv=swab"])
+        .pipe_in_fixture("seq-byte-values.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("seq-byte-values-swapped.test");
+}
+
+#[test]
+fn test_swab_257_test() {
+    new_ucmd!()
+        .args(&["conv=swab"])
+        .pipe_in_fixture("seq-byte-values-odd.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("seq-byte-values-odd.spec");
+}
+
+#[test]
+fn test_zeros_4k_conv_sync_obs_gt_ibs() {
+    new_ucmd!()
+        .args(&["conv=sync", "ibs=521", "obs=1031"])
+        .pipe_in_fixture("zeros-620f0b67a91f7f74151bc5be745b7110.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-sync-ibs-521-obs-1031-zeros.spec");
+}
+
+#[test]
+fn test_zeros_4k_conv_sync_ibs_gt_obs() {
+    new_ucmd!()
+        .args(&["conv=sync", "ibs=1031", "obs=521"])
+        .pipe_in_fixture("zeros-620f0b67a91f7f74151bc5be745b7110.test")
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-sync-ibs-1031-obs-521-zeros.spec");
+}
+
+#[test]
+fn test_deadbeef_32k_conv_sync_obs_gt_ibs() {
+    new_ucmd!()
+        .args(&[
+            "conv=sync",
+            "ibs=521",
+            "obs=1031",
+            "if=deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-sync-ibs-521-obs-1031-deadbeef.spec");
+}
+
+#[test]
+fn test_deadbeef_32k_conv_sync_ibs_gt_obs() {
+    new_ucmd!()
+        .args(&[
+            "conv=sync",
+            "ibs=1031",
+            "obs=521",
+            "if=deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-sync-ibs-1031-obs-521-deadbeef.spec");
+}
+
+#[test]
+fn test_random_73k_test_bs_prime_obs_gt_ibs_sync() {
+    new_ucmd!()
+        .args(&[
+            "conv=sync",
+            "ibs=521",
+            "obs=1031",
+            "if=random-5828891cb1230748e146f34223bbd3b5.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-sync-ibs-521-obs-1031-random.spec");
+}
+
+#[test]
+fn test_random_73k_test_bs_prime_ibs_gt_obs_sync() {
+    new_ucmd!()
+        .args(&[
+            "conv=sync",
+            "ibs=1031",
+            "obs=521",
+            "if=random-5828891cb1230748e146f34223bbd3b5.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-conv-sync-ibs-1031-obs-521-random.spec");
+}
+
+#[test]
+fn test_identity() {
+    new_ucmd!()
+        .args(&["if=zeros-620f0b67a91f7f74151bc5be745b7110.test"])
+        .succeeds()
+        .stdout_is_fixture_bytes("zeros-620f0b67a91f7f74151bc5be745b7110.test");
+    new_ucmd!()
+        .args(&["if=ones-6ae59e64850377ee5470c854761551ea.test"])
+        .succeeds()
+        .stdout_is_fixture_bytes("ones-6ae59e64850377ee5470c854761551ea.test");
+    new_ucmd!()
+        .args(&["if=deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test"])
+        .succeeds()
+        .stdout_is_fixture_bytes("deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test");
+    new_ucmd!()
+        .args(&["if=random-5828891cb1230748e146f34223bbd3b5.test"])
+        .succeeds()
+        .stdout_is_fixture_bytes("random-5828891cb1230748e146f34223bbd3b5.test");
+}
+
+#[test]
+fn test_random_73k_test_not_a_multiple_obs_gt_ibs() {
+    new_ucmd!()
+        .args(&[
+            "ibs=521",
+            "obs=1031",
+            "if=random-5828891cb1230748e146f34223bbd3b5.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("random-5828891cb1230748e146f34223bbd3b5.test");
+}
+
+#[test]
+fn test_random_73k_test_obs_lt_not_a_multiple_ibs() {
+    new_ucmd!()
+        .args(&[
+            "ibs=1031",
+            "obs=521",
+            "if=random-5828891cb1230748e146f34223bbd3b5.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("random-5828891cb1230748e146f34223bbd3b5.test");
+}
+
+#[test]
+fn test_deadbeef_all_32k_test_count_reads() {
+    new_ucmd!()
+        .args(&[
+            "bs=1024",
+            "count=32",
+            "if=deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test");
+}
+
+#[test]
+fn test_deadbeef_all_32k_test_count_bytes() {
+    new_ucmd!()
+        .args(&[
+            "ibs=531",
+            "obs=1031",
+            "count=32x1024",
+            "oflag=count_bytes",
+            "if=deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test");
+}
+
+#[test]
+fn test_deadbeef_32k_to_16k_test_count_reads() {
+    new_ucmd!()
+        .args(&[
+            "ibs=1024",
+            "obs=1031",
+            "count=16",
+            "if=deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-deadbeef-first-16k.spec");
+}
+
+#[test]
+fn test_deadbeef_32k_to_12345_test_count_bytes() {
+    new_ucmd!()
+        .args(&[
+            "ibs=531",
+            "obs=1031",
+            "count=12345",
+            "iflag=count_bytes",
+            "if=deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-deadbeef-first-12345.spec");
+}
+
+#[test]
+fn test_random_73k_test_count_reads() {
+    new_ucmd!()
+        .args(&[
+            "bs=1024",
+            "count=32",
+            "if=random-5828891cb1230748e146f34223bbd3b5.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-random-first-32k.spec");
+}
+
+#[test]
+fn test_random_73k_test_count_bytes() {
+    new_ucmd!()
+        .args(&[
+            "ibs=521",
+            "obs=1031",
+            "count=32x1024",
+            "iflag=count_bytes",
+            "if=random-5828891cb1230748e146f34223bbd3b5.test",
+        ])
+        .succeeds()
+        .stdout_is_fixture_bytes("gnudd-random-first-32k.spec");
+}
+
+#[test]
+fn test_all_valid_ascii_ebcdic_ascii_roundtrip_conv_test() {
+    let tmp = new_ucmd!()
+        .args(&["ibs=128", "obs=1024", "conv=ebcdic"])
+        .pipe_in_fixture("all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test")
+        .succeeds()
+        .stdout_move_bytes();
+    new_ucmd!()
+        .args(&["ibs=256", "obs=1024", "conv=ascii"])
+        .pipe_in(tmp)
+        .succeeds()
+        .stdout_is_fixture_bytes("all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test");
+}
+
+#[test]
+fn test_skip_zero() {
+    new_ucmd!()
+        .args(&["skip=0", "status=noxfer"])
+        .succeeds()
+        .no_stdout()
+        .stderr_is("0+0 records in\n0+0 records out\n");
+}
+
+#[test]
+fn test_truncated_record() {
+    new_ucmd!()
+        .args(&["cbs=1", "conv=block", "status=noxfer"])
+        .pipe_in("ab")
+        .succeeds()
+        .stdout_is("a")
+        .stderr_is("0+1 records in\n0+1 records out\n1 truncated record\n");
+    new_ucmd!()
+        .args(&["cbs=1", "conv=block", "status=noxfer"])
+        .pipe_in("ab\ncd\n")
+        .succeeds()
+        .stdout_is("ac")
+        .stderr_is("0+1 records in\n0+1 records out\n2 truncated records\n");
+}
+
+/// Test that the output file can be `/dev/null`.
+#[cfg(unix)]
+#[test]
+fn test_outfile_dev_null() {
+    new_ucmd!().arg("of=/dev/null").succeeds().no_stdout();
+}
+
+#[test]
+fn test_block_sync() {
+    new_ucmd!()
+        .args(&["ibs=5", "cbs=5", "conv=block,sync", "status=noxfer"])
+        .pipe_in("012\nabcde\n")
+        .succeeds()
+        // blocks:    1    2
+        .stdout_is("012  abcde")
+        .stderr_is("2+0 records in\n0+1 records out\n");
+
+    // It seems that a partial record in is represented as an
+    // all-spaces block at the end of the output. The "1 truncated
+    // record" line is present in the status report due to the line
+    // "abcdefg\n" being truncated to "abcde".
+    new_ucmd!()
+        .args(&["ibs=5", "cbs=5", "conv=block,sync", "status=noxfer"])
+        .pipe_in("012\nabcdefg\n")
+        .succeeds()
+        // blocks:    1    2    3
+        .stdout_is("012  abcde     ")
+        .stderr_is("2+1 records in\n0+1 records out\n1 truncated record\n");
+}
+
+#[test]
+fn test_bytes_iseek_bytes_iflag() {
+    new_ucmd!()
+        .args(&["iseek=10", "iflag=skip_bytes", "bs=2"])
+        .pipe_in("0123456789abcdefghijklm")
+        .succeeds()
+        .stdout_is("abcdefghijklm");
+}
+
+#[test]
+fn test_bytes_iseek_skip_additive() {
+    new_ucmd!()
+        .args(&["iseek=5", "skip=5", "iflag=skip_bytes", "bs=2"])
+        .pipe_in("0123456789abcdefghijklm")
+        .succeeds()
+        .stdout_is("abcdefghijklm");
+}
+
+#[test]
+fn test_bytes_oseek_bytes_oflag() {
+    new_ucmd!()
+        .args(&["oseek=8", "oflag=seek_bytes", "bs=2"])
+        .pipe_in("abcdefghijklm")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-bytes-alphabet-null.spec");
+}
+
+#[test]
+fn test_bytes_oseek_bytes_trunc_oflag() {
+    new_ucmd!()
+        .args(&["oseek=8", "oflag=seek_bytes", "bs=2", "count=0"])
+        .pipe_in("abcdefghijklm")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-bytes-null-trunc.spec");
+}
+
+#[test]
+fn test_bytes_oseek_seek_additive() {
+    new_ucmd!()
+        .args(&["oseek=4", "seek=4", "oflag=seek_bytes", "bs=2"])
+        .pipe_in("abcdefghijklm")
+        .succeeds()
+        .stdout_is_fixture_bytes("dd-bytes-alphabet-null.spec");
+}
diff --git a/tests/by-util/test_df.rs b/tests/by-util/test_df.rs
index ac3776b96..b0ee8a2b3 100644
--- a/tests/by-util/test_df.rs
+++ b/tests/by-util/test_df.rs
@@ -1,3 +1,4 @@
+// spell-checker:ignore udev pcent
 use crate::common::util::*;
 
 #[test]
@@ -5,6 +6,11 @@ fn test_df_compatible_no_size_arg() {
     new_ucmd!().arg("-a").succeeds();
 }
 
+#[test]
+fn test_df_shortened_long_argument() {
+    new_ucmd!().arg("--a").succeeds();
+}
+
 #[test]
 fn test_df_compatible() {
     new_ucmd!().arg("-ah").succeeds();
@@ -22,6 +28,8 @@ fn test_df_compatible_si() {
 
 #[test]
 fn test_df_output() {
+    // TODO These should fail because `-total` should have two dashes,
+    // not just one. But they don't fail.
     if cfg!(target_os = "macos") {
         new_ucmd!().arg("-H").arg("-total").succeeds().
         stdout_only("Filesystem               Size         Used    Available     Capacity  Use% Mounted on       \n");
@@ -32,4 +40,243 @@ fn test_df_output() {
     }
 }
 
-// ToDO: more tests...
+/// Test that the order of rows in the table does not change across executions.
+#[test]
+fn test_order_same() {
+    let output1 = new_ucmd!()
+        .arg("--output=source")
+        .succeeds()
+        .stdout_move_str();
+    let output2 = new_ucmd!()
+        .arg("--output=source")
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(output1, output2);
+}
+
+/// Test of mount point begin repeated
+#[cfg(unix)]
+#[test]
+fn test_output_mp_repeat() {
+    let output1 = new_ucmd!().arg("/").arg("/").succeeds().stdout_move_str();
+    let output1: Vec<String> = output1
+        .lines()
+        .map(|l| String::from(l.split_once(' ').unwrap().0))
+        .collect();
+    assert_eq!(3, output1.len());
+    assert_eq!(output1[1], output1[2]);
+}
+#[test]
+fn test_output_conflict_options() {
+    for option in ["-i", "-T", "-P"] {
+        new_ucmd!().arg("--output=source").arg(option).fails();
+    }
+}
+
+#[test]
+fn test_output_option() {
+    new_ucmd!().arg("--output").succeeds();
+    new_ucmd!().arg("--output=source,target").succeeds();
+    new_ucmd!().arg("--output=invalid_option").fails();
+}
+
+#[test]
+fn test_output_option_without_equals_sign() {
+    new_ucmd!().arg("--output").arg(".").succeeds();
+}
+
+#[test]
+fn test_type_option() {
+    new_ucmd!().args(&["-t", "ext4", "-t", "ext3"]).succeeds();
+}
+
+#[test]
+fn test_exclude_type_option() {
+    new_ucmd!().args(&["-x", "ext4", "-x", "ext3"]).succeeds();
+}
+
+#[test]
+fn test_total() {
+    // Example output:
+    //
+    //     Filesystem            1K-blocks     Used Available Use% Mounted on
+    //     udev                    3858016        0   3858016   0% /dev
+    //     ...
+    //     /dev/loop14               63488    63488         0 100% /snap/core20/1361
+    //     total                 258775268 98099712 148220200  40% -
+    let output = new_ucmd!().arg("--total").succeeds().stdout_move_str();
+
+    // Skip the header line.
+    let lines: Vec<&str> = output.lines().skip(1).collect();
+
+    // Parse the values from the last row.
+    let last_line = lines.last().unwrap();
+    let mut iter = last_line.split_whitespace();
+    assert_eq!(iter.next().unwrap(), "total");
+    let reported_total_size = iter.next().unwrap().parse().unwrap();
+    let reported_total_used = iter.next().unwrap().parse().unwrap();
+    let reported_total_avail = iter.next().unwrap().parse().unwrap();
+
+    // Loop over each row except the last, computing the sum of each column.
+    let mut computed_total_size = 0;
+    let mut computed_total_used = 0;
+    let mut computed_total_avail = 0;
+    let n = lines.len();
+    for line in &lines[..n - 1] {
+        let mut iter = line.split_whitespace();
+        iter.next().unwrap();
+        computed_total_size += iter.next().unwrap().parse::<u64>().unwrap();
+        computed_total_used += iter.next().unwrap().parse::<u64>().unwrap();
+        computed_total_avail += iter.next().unwrap().parse::<u64>().unwrap();
+    }
+
+    // Check that the sum of each column matches the reported value in
+    // the last row.
+    assert_eq!(computed_total_size, reported_total_size);
+    assert_eq!(computed_total_used, reported_total_used);
+    assert_eq!(computed_total_avail, reported_total_avail);
+}
+
+#[test]
+fn test_use_percentage() {
+    let output = new_ucmd!()
+        .args(&["--total", "--output=used,avail,pcent"])
+        .succeeds()
+        .stdout_move_str();
+
+    // Skip the header line.
+    let lines: Vec<&str> = output.lines().skip(1).collect();
+
+    for line in lines {
+        let mut iter = line.split_whitespace();
+        let reported_used = iter.next().unwrap().parse::<f64>().unwrap();
+        let reported_avail = iter.next().unwrap().parse::<f64>().unwrap();
+        let reported_percentage = iter.next().unwrap();
+        let reported_percentage = reported_percentage[..reported_percentage.len() - 1]
+            .parse::<u8>()
+            .unwrap();
+        let computed_percentage =
+            (100.0 * (reported_used / (reported_used + reported_avail))).ceil() as u8;
+
+        assert_eq!(computed_percentage, reported_percentage);
+    }
+}
+
+#[test]
+fn test_block_size_1024() {
+    fn get_header(block_size: u64) -> String {
+        // TODO When #3057 is resolved, we should just use
+        //
+        //     new_ucmd!().arg("--output=size").succeeds().stdout_move_str();
+        //
+        // instead of parsing the entire `df` table as a string.
+        let output = new_ucmd!()
+            .args(&["-B", &format!("{}", block_size)])
+            .succeeds()
+            .stdout_move_str();
+        let first_line = output.lines().next().unwrap();
+        let mut column_labels = first_line.split_whitespace();
+        let size_column_label = column_labels.nth(1).unwrap();
+        size_column_label.into()
+    }
+
+    assert_eq!(get_header(1024), "1K-blocks");
+    assert_eq!(get_header(2048), "2K-blocks");
+    assert_eq!(get_header(4096), "4K-blocks");
+    assert_eq!(get_header(1024 * 1024), "1M-blocks");
+    assert_eq!(get_header(2 * 1024 * 1024), "2M-blocks");
+    assert_eq!(get_header(1024 * 1024 * 1024), "1G-blocks");
+    assert_eq!(get_header(34 * 1024 * 1024 * 1024), "34G-blocks");
+}
+
+// TODO The spacing does not match GNU df. Also we need to remove
+// trailing spaces from the heading row.
+#[test]
+fn test_output_selects_columns() {
+    let output = new_ucmd!()
+        .args(&["--output=source"])
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(output.lines().next().unwrap(), "Filesystem       ");
+
+    let output = new_ucmd!()
+        .args(&["--output=source,target"])
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(
+        output.lines().next().unwrap(),
+        "Filesystem       Mounted on       "
+    );
+
+    let output = new_ucmd!()
+        .args(&["--output=source,target,used"])
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(
+        output.lines().next().unwrap(),
+        "Filesystem       Mounted on               Used "
+    );
+}
+
+#[test]
+fn test_output_multiple_occurrences() {
+    let output = new_ucmd!()
+        .args(&["--output=source", "--output=target"])
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(
+        output.lines().next().unwrap(),
+        "Filesystem       Mounted on       "
+    );
+}
+
+// TODO Fix the spacing.
+#[test]
+fn test_output_file_all_filesystems() {
+    // When run with no positional arguments, `df` lets "-" represent
+    // the "File" entry for each row.
+    let output = new_ucmd!()
+        .arg("--output=file")
+        .succeeds()
+        .stdout_move_str();
+    let mut lines = output.lines();
+    assert_eq!(lines.next().unwrap(), "File            ");
+    for line in lines {
+        assert_eq!(line, "-               ");
+    }
+}
+
+// TODO Fix the spacing.
+#[test]
+fn test_output_file_specific_files() {
+    // Create three files.
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("a");
+    at.touch("b");
+    at.touch("c");
+
+    // When run with positional arguments, the filesystems should
+    // appear in the "File" column.
+    let output = ucmd
+        .args(&["--output=file", "a", "b", "c"])
+        .succeeds()
+        .stdout_move_str();
+    let actual: Vec<&str> = output.lines().collect();
+    assert_eq!(
+        actual,
+        vec![
+            "File            ",
+            "a               ",
+            "b               ",
+            "c               "
+        ]
+    );
+}
+
+#[test]
+fn test_output_field_no_more_than_once() {
+    new_ucmd!()
+        .arg("--output=target,source,target")
+        .fails()
+        .usage_error("option --output: field 'target' used more than once");
+}
diff --git a/tests/by-util/test_du.rs b/tests/by-util/test_du.rs
index efc097773..b0506d071 100644
--- a/tests/by-util/test_du.rs
+++ b/tests/by-util/test_du.rs
@@ -179,15 +179,15 @@ fn test_du_hard_link() {
 
 #[cfg(target_vendor = "apple")]
 fn _du_hard_link(s: &str) {
-    assert_eq!(s, "12\tsubdir/links\n")
+    assert_eq!(s, "12\tsubdir/links\n");
 }
 #[cfg(target_os = "windows")]
 fn _du_hard_link(s: &str) {
-    assert_eq!(s, "8\tsubdir/links\n")
+    assert_eq!(s, "8\tsubdir/links\n");
 }
 #[cfg(target_os = "freebsd")]
 fn _du_hard_link(s: &str) {
-    assert_eq!(s, "16\tsubdir/links\n")
+    assert_eq!(s, "16\tsubdir/links\n");
 }
 #[cfg(all(
     not(target_vendor = "apple"),
diff --git a/tests/by-util/test_echo.rs b/tests/by-util/test_echo.rs
index 09ed9658f..401e16706 100644
--- a/tests/by-util/test_echo.rs
+++ b/tests/by-util/test_echo.rs
@@ -138,11 +138,19 @@ fn test_escape_short_octal() {
 }
 
 #[test]
-fn test_escape_no_octal() {
+fn test_escape_nul() {
     new_ucmd!()
         .args(&["-e", "foo\\0 bar"])
         .succeeds()
-        .stdout_only("foo\\0 bar\n");
+        .stdout_only("foo\0 bar\n");
+}
+
+#[test]
+fn test_escape_octal_invalid_digit() {
+    new_ucmd!()
+        .args(&["-e", "foo\\08 bar"])
+        .succeeds()
+        .stdout_only("foo\u{0}8 bar\n");
 }
 
 #[test]
diff --git a/tests/by-util/test_env.rs b/tests/by-util/test_env.rs
index 1d76c433d..3559e74cd 100644
--- a/tests/by-util/test_env.rs
+++ b/tests/by-util/test_env.rs
@@ -1,7 +1,4 @@
-// spell-checker:ignore (words) bamf chdir
-
-#[cfg(not(windows))]
-use std::fs;
+// spell-checker:ignore (words) bamf chdir rlimit prlimit COMSPEC
 
 use crate::common::util::*;
 use std::env;
@@ -80,6 +77,20 @@ fn test_combined_file_set_unset() {
     );
 }
 
+#[test]
+fn test_unset_invalid_variables() {
+    use uucore::display::Quotable;
+
+    // Cannot test input with \0 in it, since output will also contain \0. rlimit::prlimit fails
+    // with this error: Error { kind: InvalidInput, message: "nul byte found in provided data" }
+    for var in &["", "a=b"] {
+        new_ucmd!().arg("-u").arg(var).run().stderr_only(format!(
+            "env: cannot unset {}: Invalid argument",
+            var.quote()
+        ));
+    }
+}
+
 #[test]
 fn test_single_name_value_pair() {
     let out = new_ucmd!().arg("FOO=bar").run();
@@ -108,6 +119,15 @@ fn test_ignore_environment() {
     scene.ucmd().arg("-").run().no_stdout();
 }
 
+#[test]
+fn test_empty_name() {
+    new_ucmd!()
+        .arg("-i")
+        .arg("=xyz")
+        .run()
+        .stderr_only("env: warning: no name specified for value 'xyz'");
+}
+
 #[test]
 fn test_null_delimiter() {
     let out = new_ucmd!()
@@ -154,7 +174,7 @@ fn test_fail_null_with_program() {
 fn test_change_directory() {
     let scene = TestScenario::new(util_name!());
     let temporary_directory = tempdir().unwrap();
-    let temporary_path = fs::canonicalize(temporary_directory.path()).unwrap();
+    let temporary_path = std::fs::canonicalize(temporary_directory.path()).unwrap();
     assert_ne!(env::current_dir().unwrap(), temporary_path);
 
     // command to print out current working directory
@@ -167,30 +187,39 @@ fn test_change_directory() {
         .arg(pwd)
         .succeeds()
         .stdout_move_str();
-    assert_eq!(out.trim(), temporary_path.as_os_str())
+    assert_eq!(out.trim(), temporary_path.as_os_str());
 }
 
-// no way to consistently get "current working directory", `cd` doesn't work @ CI
-// instead, we test that the unique temporary directory appears somewhere in the printed variables
 #[cfg(windows)]
 #[test]
 fn test_change_directory() {
     let scene = TestScenario::new(util_name!());
     let temporary_directory = tempdir().unwrap();
-    let temporary_path = temporary_directory.path();
 
-    assert_ne!(env::current_dir().unwrap(), temporary_path);
+    let temporary_path = temporary_directory.path();
+    let temporary_path = temporary_path
+        .strip_prefix(r"\\?\")
+        .unwrap_or(temporary_path);
+
+    let env_cd = env::current_dir().unwrap();
+    let env_cd = env_cd.strip_prefix(r"\\?\").unwrap_or(&env_cd);
+
+    assert_ne!(env_cd, temporary_path);
+
+    // COMSPEC is a variable that contains the full path to cmd.exe
+    let cmd_path = env::var("COMSPEC").unwrap();
+
+    // command to print out current working directory
+    let pwd = [&*cmd_path, "/C", "cd"];
 
     let out = scene
         .ucmd()
         .arg("--chdir")
         .arg(&temporary_path)
+        .args(&pwd)
         .succeeds()
         .stdout_move_str();
-
-    assert!(!out
-        .lines()
-        .any(|line| line.ends_with(temporary_path.file_name().unwrap().to_str().unwrap())));
+    assert_eq!(out.trim(), temporary_path.as_os_str());
 }
 
 #[test]
diff --git a/tests/by-util/test_expr.rs b/tests/by-util/test_expr.rs
index 30e3016a3..3a753aa1b 100644
--- a/tests/by-util/test_expr.rs
+++ b/tests/by-util/test_expr.rs
@@ -1,3 +1,5 @@
+// spell-checker:ignore αbcdef
+
 use crate::common::util::*;
 
 #[test]
@@ -95,6 +97,27 @@ fn test_and() {
     new_ucmd!().args(&["", "&", "1"]).run().stdout_is("0\n");
 }
 
+#[test]
+fn test_length_fail() {
+    new_ucmd!().args(&["length", "αbcdef", "1"]).fails();
+}
+
+#[test]
+fn test_length() {
+    new_ucmd!()
+        .args(&["length", "abcdef"])
+        .succeeds()
+        .stdout_only("6\n");
+}
+
+#[test]
+fn test_length_mb() {
+    new_ucmd!()
+        .args(&["length", "αbcdef"])
+        .succeeds()
+        .stdout_only("6\n");
+}
+
 #[test]
 fn test_substr() {
     new_ucmd!()
diff --git a/tests/by-util/test_factor.rs b/tests/by-util/test_factor.rs
index bcb1238bf..7c1e540b6 100644
--- a/tests/by-util/test_factor.rs
+++ b/tests/by-util/test_factor.rs
@@ -29,6 +29,8 @@ const NUM_TESTS: usize = 100;
 
 #[test]
 fn test_parallel() {
+    use hex_literal::hex;
+    use sha1::{Digest, Sha1};
     // factor should only flush the buffer at line breaks
     let n_integers = 100_000;
     let mut input_string = String::new();
@@ -60,13 +62,20 @@ fn test_parallel() {
         .ccmd("sort")
         .arg(tmp_dir.plus("output"))
         .succeeds();
-    let hash_check = sha1::Sha1::from(result.stdout()).hexdigest();
-    assert_eq!(hash_check, "cc743607c0ff300ff575d92f4ff0c87d5660c393");
+    let mut hasher = Sha1::new();
+    hasher.update(result.stdout());
+    let hash_check = hasher.finalize();
+    assert_eq!(
+        hash_check[..],
+        hex!("cc743607c0ff300ff575d92f4ff0c87d5660c393")
+    );
 }
 
 #[test]
 fn test_first_100000_integers() {
     extern crate sha1;
+    use hex_literal::hex;
+    use sha1::{Digest, Sha1};
 
     let n_integers = 100_000;
     let mut input_string = String::new();
@@ -78,8 +87,13 @@ fn test_first_100000_integers() {
     let result = new_ucmd!().pipe_in(input_string.as_bytes()).succeeds();
 
     // `seq 0 100000 | factor | sha1sum` => "4ed2d8403934fa1c76fe4b84c5d4b8850299c359"
-    let hash_check = sha1::Sha1::from(result.stdout()).hexdigest();
-    assert_eq!(hash_check, "4ed2d8403934fa1c76fe4b84c5d4b8850299c359");
+    let mut hasher = Sha1::new();
+    hasher.update(result.stdout());
+    let hash_check = hasher.finalize();
+    assert_eq!(
+        hash_check[..],
+        hex!("4ed2d8403934fa1c76fe4b84c5d4b8850299c359")
+    );
 }
 
 #[test]
@@ -115,7 +129,7 @@ fn test_random() {
             // log distribution---higher probability for lower numbers
             let factor;
             loop {
-                let next = rng.gen_range(0_f64, log_num_primes).exp2().floor() as usize;
+                let next = rng.gen_range(0_f64..log_num_primes).exp2().floor() as usize;
                 if next < NUM_PRIMES {
                     factor = primes[next];
                     break;
diff --git a/tests/by-util/test_false.rs b/tests/by-util/test_false.rs
index bbabc7a52..5ce64e7a8 100644
--- a/tests/by-util/test_false.rs
+++ b/tests/by-util/test_false.rs
@@ -1,6 +1,53 @@
 use crate::common::util::*;
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+use std::fs::OpenOptions;
 
 #[test]
 fn test_exit_code() {
     new_ucmd!().fails();
 }
+
+#[test]
+fn test_version() {
+    new_ucmd!()
+        .args(&["--version"])
+        .fails()
+        .stdout_contains("false");
+}
+
+#[test]
+fn test_help() {
+    new_ucmd!()
+        .args(&["--help"])
+        .fails()
+        .stdout_contains("false");
+}
+
+#[test]
+fn test_short_options() {
+    for option in ["-h", "-V"] {
+        new_ucmd!().arg(option).fails().stdout_is("");
+    }
+}
+
+#[test]
+fn test_conflict() {
+    new_ucmd!()
+        .args(&["--help", "--version"])
+        .fails()
+        .stdout_is("");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+fn test_full() {
+    for option in ["--version", "--help"] {
+        let dev_full = OpenOptions::new().write(true).open("/dev/full").unwrap();
+
+        new_ucmd!()
+            .arg(option)
+            .set_stdout(dev_full)
+            .fails()
+            .stderr_contains("No space left on device");
+    }
+}
diff --git a/tests/by-util/test_hashsum.rs b/tests/by-util/test_hashsum.rs
index 545b4ee78..293270a77 100644
--- a/tests/by-util/test_hashsum.rs
+++ b/tests/by-util/test_hashsum.rs
@@ -80,4 +80,5 @@ test_digest! {
     shake128_256 shake128 256
     shake256_512 shake256 512
     b2sum b2sum 512
+    b3sum b3sum 256
 }
diff --git a/tests/by-util/test_head.rs b/tests/by-util/test_head.rs
index 246f5b62a..20bec7589 100644
--- a/tests/by-util/test_head.rs
+++ b/tests/by-util/test_head.rs
@@ -157,11 +157,17 @@ fn test_negative_byte_syntax() {
 #[test]
 fn test_negative_zero_lines() {
     new_ucmd!()
-        .args(&["--lines=-0"])
+        .arg("--lines=-0")
         .pipe_in("a\nb\n")
         .succeeds()
         .stdout_is("a\nb\n");
+    new_ucmd!()
+        .arg("--lines=-0")
+        .pipe_in("a\nb")
+        .succeeds()
+        .stdout_is("a\nb");
 }
+
 #[test]
 fn test_negative_zero_bytes() {
     new_ucmd!()
@@ -220,9 +226,9 @@ fn test_zero_terminated() {
 fn test_obsolete_extras() {
     new_ucmd!()
         .args(&["-5zv"])
-        .pipe_in("1\02\03\04\05\06")
+        .pipe_in("1\x002\x003\x004\x005\x006")
         .succeeds()
-        .stdout_is("==> standard input <==\n1\02\03\04\05\0");
+        .stdout_is("==> standard input <==\n1\x002\x003\x004\x005\0");
 }
 
 #[test]
@@ -295,17 +301,24 @@ fn test_head_invalid_num() {
     #[cfg(target_pointer_width = "32")]
     {
         let sizes = ["1000G", "10T"];
+        for size in &sizes {
+            new_ucmd!().args(&["-c", size]).succeeds();
+        }
+    }
+    #[cfg(target_pointer_width = "32")]
+    {
+        let sizes = ["-1000G", "-10T"];
         for size in &sizes {
             new_ucmd!()
                 .args(&["-c", size])
                 .fails()
-                .code_is(1)
-                .stderr_only(format!(
-                    "head: invalid number of bytes: '{}': Value too large for defined data type",
-                    size
-                ));
+                .stderr_is("head: out of range integral type conversion attempted: number of bytes is too large");
         }
     }
+    new_ucmd!()
+        .args(&["-c", "-³"])
+        .fails()
+        .stderr_is("head: invalid number of bytes: '³'");
 }
 
 #[test]
@@ -329,3 +342,21 @@ fn test_head_num_with_undocumented_sign_bytes() {
         .succeeds()
         .stdout_is("abcde");
 }
+
+#[test]
+fn test_presume_input_pipe_default() {
+    new_ucmd!()
+        .args(&["---presume-input-pipe"])
+        .pipe_in_fixture(INPUT)
+        .run()
+        .stdout_is_fixture("lorem_ipsum_default.expected");
+}
+
+#[test]
+fn test_presume_input_pipe_5_chars() {
+    new_ucmd!()
+        .args(&["-c", "5", "---presume-input-pipe"])
+        .pipe_in_fixture(INPUT)
+        .run()
+        .stdout_is_fixture("lorem_ipsum_5_chars.expected");
+}
diff --git a/tests/by-util/test_install.rs b/tests/by-util/test_install.rs
index 339a40454..0c775d145 100644
--- a/tests/by-util/test_install.rs
+++ b/tests/by-util/test_install.rs
@@ -9,16 +9,6 @@ use std::process::Command;
 #[cfg(target_os = "linux")]
 use std::thread::sleep;
 
-#[test]
-fn test_install_help() {
-    let (_, mut ucmd) = at_and_ucmd!();
-
-    ucmd.arg("--help")
-        .succeeds()
-        .no_stderr()
-        .stdout_contains("FLAGS:");
-}
-
 #[test]
 fn test_install_basic() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -493,7 +483,7 @@ fn test_install_copy_then_compare_file() {
     file2_meta = at.metadata(file2);
     let after = FileTime::from_last_modification_time(&file2_meta);
 
-    assert!(before == after);
+    assert_eq!(before, after);
 }
 
 #[test]
@@ -825,6 +815,31 @@ fn test_install_backup_short_custom_suffix() {
     assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
 }
 
+#[test]
+fn test_install_backup_short_custom_suffix_hyphen_value() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file_a = "test_install_backup_custom_suffix_file_a";
+    let file_b = "test_install_backup_custom_suffix_file_b";
+    let suffix = "-v";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    scene
+        .ucmd()
+        .arg("-b")
+        .arg(format!("--suffix={}", suffix))
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+}
+
 #[test]
 fn test_install_backup_custom_suffix_via_env() {
     let scene = TestScenario::new(util_name!());
@@ -1085,3 +1100,67 @@ fn test_install_backup_off() {
     assert!(at.file_exists(file_b));
     assert!(!at.file_exists(&format!("{}~", file_b)));
 }
+
+#[test]
+fn test_install_missing_arguments() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .fails()
+        .stderr_contains("install: missing file operand");
+}
+
+#[test]
+fn test_install_missing_destination() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file_1 = "source_file1";
+
+    at.touch(file_1);
+    scene.ucmd().arg(file_1).fails().stderr_contains(format!(
+        "install: missing destination file operand after '{}'",
+        file_1
+    ));
+}
+
+#[test]
+fn test_install_dir_dot() {
+    // To match tests/install/d-slashdot.sh
+    let scene = TestScenario::new(util_name!());
+
+    scene.ucmd().arg("-d").arg("dir1/.").succeeds();
+    scene.ucmd().arg("-d").arg("dir2/..").succeeds();
+    // Tests that we don't have dir3/. in the output
+    // but only 'dir3'
+    scene
+        .ucmd()
+        .arg("-d")
+        .arg("dir3/.")
+        .arg("-v")
+        .succeeds()
+        .stdout_contains("creating directory 'dir3'");
+    scene
+        .ucmd()
+        .arg("-d")
+        .arg("dir4/./cal")
+        .arg("-v")
+        .succeeds()
+        .stdout_contains("creating directory 'dir4/./cal'");
+    scene
+        .ucmd()
+        .arg("-d")
+        .arg("dir5/./cali/.")
+        .arg("-v")
+        .succeeds()
+        .stdout_contains("creating directory 'dir5/cali'");
+
+    let at = &scene.fixtures;
+
+    assert!(at.dir_exists("dir1"));
+    assert!(at.dir_exists("dir2"));
+    assert!(at.dir_exists("dir3"));
+    assert!(at.dir_exists("dir4/cal"));
+    assert!(at.dir_exists("dir5/cali"));
+}
diff --git a/tests/by-util/test_join.rs b/tests/by-util/test_join.rs
index 1d92bf8e7..d5da873f6 100644
--- a/tests/by-util/test_join.rs
+++ b/tests/by-util/test_join.rs
@@ -1,6 +1,12 @@
-// spell-checker:ignore (words) autoformat
+// spell-checker:ignore (words) autoformat nocheck
 
 use crate::common::util::*;
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+use std::fs::OpenOptions;
+#[cfg(unix)]
+use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
+#[cfg(windows)]
+use std::{ffi::OsString, os::windows::ffi::OsStringExt};
 
 #[test]
 fn empty_files() {
@@ -75,6 +81,27 @@ fn different_field() {
         .stdout_only_fixture("different_field.expected");
 }
 
+#[test]
+fn out_of_bounds_fields() {
+    new_ucmd!()
+        .arg("fields_1.txt")
+        .arg("fields_4.txt")
+        .arg("-1")
+        .arg("3")
+        .arg("-2")
+        .arg("5")
+        .succeeds()
+        .stdout_only_fixture("out_of_bounds_fields.expected");
+
+    new_ucmd!()
+        .arg("fields_1.txt")
+        .arg("fields_4.txt")
+        .arg("-j")
+        .arg("100000000000000000000") // > usize::MAX for 64 bits
+        .succeeds()
+        .stdout_only_fixture("out_of_bounds_fields.expected");
+}
+
 #[test]
 fn unpaired_lines() {
     new_ucmd!()
@@ -281,13 +308,66 @@ fn missing_format_fields() {
         .stdout_only_fixture("missing_format_fields.expected");
 }
 
+#[test]
+fn nocheck_order() {
+    new_ucmd!()
+        .arg("fields_1.txt")
+        .arg("fields_2.txt")
+        .arg("--nocheck-order")
+        .succeeds()
+        .stdout_only_fixture("default.expected");
+}
+
 #[test]
 fn wrong_line_order() {
+    let ts = TestScenario::new(util_name!());
     new_ucmd!()
         .arg("fields_2.txt")
         .arg("fields_4.txt")
         .fails()
-        .stderr_is("fields_4.txt:5: is not sorted");
+        .stdout_contains("7 g f 4 fg")
+        .stderr_is(&format!(
+            "{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order",
+            ts.bin_path.to_string_lossy(),
+            ts.util_name
+        ));
+
+    new_ucmd!()
+        .arg("--check-order")
+        .arg("fields_2.txt")
+        .arg("fields_4.txt")
+        .fails()
+        .stdout_does_not_contain("7 g f 4 fg")
+        .stderr_is(&format!(
+            "{0}: fields_4.txt:5: is not sorted: 11 g 5 gh",
+            ts.util_name
+        ));
+}
+
+#[test]
+fn both_files_wrong_line_order() {
+    let ts = TestScenario::new(util_name!());
+    new_ucmd!()
+        .arg("fields_4.txt")
+        .arg("fields_5.txt")
+        .fails()
+        .stdout_contains("5 e 3 ef")
+        .stderr_is(&format!(
+            "{0} {1}: fields_5.txt:4: is not sorted: 3\n{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order",
+            ts.bin_path.to_string_lossy(),
+            ts.util_name
+        ));
+
+    new_ucmd!()
+        .arg("--check-order")
+        .arg("fields_4.txt")
+        .arg("fields_5.txt")
+        .fails()
+        .stdout_does_not_contain("5 e 3 ef")
+        .stderr_is(&format!(
+            "{0}: fields_5.txt:4: is not sorted: 3",
+            ts.util_name
+        ));
 }
 
 #[test]
@@ -328,3 +408,80 @@ fn single_file_with_header() {
         .succeeds()
         .stdout_is("A 1\n");
 }
+
+#[test]
+fn non_line_feeds() {
+    new_ucmd!()
+        .arg("non-line_feeds_1.txt")
+        .arg("non-line_feeds_2.txt")
+        .succeeds()
+        .stdout_only_fixture("non-line_feeds.expected");
+}
+
+#[test]
+fn non_unicode() {
+    new_ucmd!()
+        .arg("non-unicode_1.bin")
+        .arg("non-unicode_2.bin")
+        .succeeds()
+        .stdout_only_fixture("non-unicode.expected");
+
+    #[cfg(unix)]
+    {
+        let invalid_utf8: u8 = 167;
+        new_ucmd!()
+            .arg("-t")
+            .arg(OsStr::from_bytes(&[invalid_utf8]))
+            .arg("non-unicode_1.bin")
+            .arg("non-unicode_2.bin")
+            .succeeds()
+            .stdout_only_fixture("non-unicode_sep.expected");
+    }
+
+    #[cfg(windows)]
+    {
+        let invalid_utf16: OsString = OsStringExt::from_wide(&[0xD800]);
+        new_ucmd!()
+            .arg("-t")
+            .arg(&invalid_utf16)
+            .arg("non-unicode_1.bin")
+            .arg("non-unicode_2.bin")
+            .fails()
+            .stderr_is(
+                "join: unprintable field separators are only supported on unix-like platforms",
+            );
+    }
+}
+
+#[test]
+fn null_field_separators() {
+    new_ucmd!()
+        .arg("-t")
+        .arg("\\0")
+        .arg("non-unicode_1.bin")
+        .arg("non-unicode_2.bin")
+        .succeeds()
+        .stdout_only_fixture("null-sep.expected");
+}
+
+#[test]
+fn null_line_endings() {
+    new_ucmd!()
+        .arg("-z")
+        .arg("non-unicode_1.bin")
+        .arg("non-unicode_2.bin")
+        .succeeds()
+        .stdout_only_fixture("z.expected");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+fn test_full() {
+    let dev_full = OpenOptions::new().write(true).open("/dev/full").unwrap();
+    new_ucmd!()
+        .arg("fields_1.txt")
+        .arg("fields_2.txt")
+        .set_stdout(dev_full)
+        .fails()
+        .stderr_contains("No space left on device");
+}
diff --git a/tests/by-util/test_kill.rs b/tests/by-util/test_kill.rs
index 40b9cec67..7581086a0 100644
--- a/tests/by-util/test_kill.rs
+++ b/tests/by-util/test_kill.rs
@@ -13,8 +13,8 @@ impl Target {
     // Creates a target that will naturally die after some time if not killed
     // fast enough.
     // This timeout avoids hanging failing tests.
-    fn new() -> Target {
-        Target {
+    fn new() -> Self {
+        Self {
             child: Command::new("sleep")
                 .arg("30")
                 .spawn()
diff --git a/tests/by-util/test_link.rs b/tests/by-util/test_link.rs
index 6ac3f35cc..6e98f1d64 100644
--- a/tests/by-util/test_link.rs
+++ b/tests/by-util/test_link.rs
@@ -23,7 +23,7 @@ fn test_link_no_circular() {
 
     ucmd.args(&[link, link])
         .fails()
-        .stderr_is("link: No such file or directory (os error 2)\n");
+        .stderr_is("link: cannot create link 'test_link_no_circular' to 'test_link_no_circular': No such file or directory");
     assert!(!at.file_exists(link));
 }
 
@@ -35,7 +35,7 @@ fn test_link_nonexistent_file() {
 
     ucmd.args(&[file, link])
         .fails()
-        .stderr_is("link: No such file or directory (os error 2)\n");
+        .stderr_only("link: cannot create link 'test_link_nonexistent_file_link' to 'test_link_nonexistent_file': No such file or directory");
     assert!(!at.file_exists(file));
     assert!(!at.file_exists(link));
 }
@@ -45,7 +45,7 @@ fn test_link_one_argument() {
     let (_, mut ucmd) = at_and_ucmd!();
     let file = "test_link_argument";
     ucmd.args(&[file]).fails().stderr_contains(
-        "error: The argument '<FILES>...' requires at least 2 values, but only 1 was provide",
+        "error: The argument '<FILES>...' requires at least 2 values but only 1 was provided",
     );
 }
 
@@ -58,6 +58,6 @@ fn test_link_three_arguments() {
         "test_link_argument3",
     ];
     ucmd.args(&arguments[..]).fails().stderr_contains(
-        format!("error: The value '{}' was provided to '<FILES>...', but it wasn't expecting any more values", arguments[2]),
+        format!("error: The value '{}' was provided to '<FILES>...' but it wasn't expecting any more values", arguments[2]),
     );
 }
diff --git a/tests/by-util/test_ln.rs b/tests/by-util/test_ln.rs
index 9fa73c0bc..0dcde3b35 100644
--- a/tests/by-util/test_ln.rs
+++ b/tests/by-util/test_ln.rs
@@ -180,6 +180,33 @@ fn test_symlink_custom_backup_suffix() {
     assert_eq!(at.resolve_link(backup), file);
 }
 
+#[test]
+fn test_symlink_custom_backup_suffix_hyphen_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_symlink_custom_backup_suffix";
+    let link = "test_symlink_custom_backup_suffix_link";
+    let suffix = "-v";
+
+    at.touch(file);
+    at.symlink_file(file, link);
+    assert!(at.file_exists(file));
+    assert!(at.is_symlink(link));
+    assert_eq!(at.resolve_link(link), file);
+
+    let arg = &format!("--suffix={}", suffix);
+    ucmd.args(&["-b", arg, "-s", file, link])
+        .succeeds()
+        .no_stderr();
+    assert!(at.file_exists(file));
+
+    assert!(at.is_symlink(link));
+    assert_eq!(at.resolve_link(link), file);
+
+    let backup = &format!("{}{}", link, suffix);
+    assert!(at.is_symlink(backup));
+    assert_eq!(at.resolve_link(backup), file);
+}
+
 #[test]
 fn test_symlink_backup_numbering() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -588,3 +615,38 @@ fn test_relative_recursive() {
     ucmd.args(&["-sr", "dir", "dir/recursive"]).succeeds();
     assert_eq!(at.resolve_link("dir/recursive"), ".");
 }
+
+#[test]
+fn test_backup_same_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("file1");
+    ucmd.args(&["--backup", "file1", "./file1"])
+        .fails()
+        .stderr_contains("n: failed to link 'file1' to './file1': Same file");
+}
+
+#[test]
+fn test_backup_force() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("a", "a\n");
+    at.write("b", "b2\n");
+
+    scene.ucmd().args(&["-s", "b", "b~"]).succeeds().no_stderr();
+    assert!(at.file_exists("a"));
+    assert!(at.file_exists("b"));
+    assert!(at.file_exists("b~"));
+    scene
+        .ucmd()
+        .args(&["-f", "--b=simple", "a", "b"])
+        .succeeds()
+        .no_stderr();
+    assert!(at.file_exists("a"));
+    assert!(at.file_exists("b"));
+    assert!(at.file_exists("b~"));
+    assert_eq!(at.read("a"), "a\n");
+    assert_eq!(at.read("b"), "a\n");
+    // we should have the same content as b as we had time to do a backup
+    assert_eq!(at.read("b~"), "b2\n");
+}
diff --git a/tests/by-util/test_ls.rs b/tests/by-util/test_ls.rs
index 56711d6e0..f60d53b6e 100644
--- a/tests/by-util/test_ls.rs
+++ b/tests/by-util/test_ls.rs
@@ -1,33 +1,55 @@
 // spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile
 
-#[cfg(unix)]
-extern crate unix_socket;
-use crate::common::util::*;
-
-extern crate regex;
-use self::regex::Regex;
-
-use std::collections::HashMap;
-use std::path::Path;
-use std::thread::sleep;
-use std::time::Duration;
-
 #[cfg(not(windows))]
 extern crate libc;
+extern crate regex;
 #[cfg(not(windows))]
-use self::libc::umask;
+extern crate tempfile;
+#[cfg(unix)]
+extern crate unix_socket;
+
+use self::regex::Regex;
+use crate::common::util::*;
+#[cfg(all(unix, feature = "chmod"))]
+use nix::unistd::{close, dup};
+use std::collections::HashMap;
+#[cfg(all(unix, feature = "chmod"))]
+use std::os::unix::io::IntoRawFd;
+use std::path::Path;
 #[cfg(not(windows))]
 use std::path::PathBuf;
 #[cfg(not(windows))]
 use std::sync::Mutex;
-#[cfg(not(windows))]
-extern crate tempfile;
+use std::thread::sleep;
+use std::time::Duration;
 
 #[cfg(not(windows))]
 lazy_static! {
     static ref UMASK_MUTEX: Mutex<()> = Mutex::new(());
 }
 
+const LONG_ARGS: &[&str] = &[
+    "-l",
+    "--long",
+    "--l",
+    "--format=long",
+    "--for=long",
+    "--format=verbose",
+    "--for=verbose",
+];
+
+const ACROSS_ARGS: &[&str] = &[
+    "-x",
+    "--format=across",
+    "--format=horizontal",
+    "--for=across",
+    "--for=horizontal",
+];
+
+const COMMA_ARGS: &[&str] = &["-m", "--format=commas", "--for=commas"];
+
+const COLUMN_ARGS: &[&str] = &["-C", "--format=columns", "--for=columns"];
+
 #[test]
 fn test_ls_ls() {
     new_ucmd!().succeeds();
@@ -40,6 +62,464 @@ fn test_ls_i() {
 }
 
 #[test]
+fn test_ls_ordering() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("some-dir1");
+    at.mkdir("some-dir2");
+    at.mkdir("some-dir3");
+    at.mkdir("some-dir4");
+    at.mkdir("some-dir5");
+    at.mkdir("some-dir6");
+
+    scene
+        .ucmd()
+        .arg("-Rl")
+        .succeeds()
+        .stdout_matches(&Regex::new("some-dir1:\\ntotal 0").unwrap());
+}
+
+#[cfg(all(feature = "truncate", feature = "dd"))]
+#[test]
+fn test_ls_allocation_size() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("some-dir1");
+    at.touch("some-dir1/empty-file");
+
+    #[cfg(unix)]
+    {
+        scene
+            .ccmd("truncate")
+            .arg("-s")
+            .arg("4M")
+            .arg("some-dir1/file-with-holes")
+            .succeeds();
+
+        // fill empty file with zeros
+        scene
+            .ccmd("dd")
+            .arg("--if=/dev/zero")
+            .arg("--of=some-dir1/zero-file")
+            .arg("bs=1024")
+            .arg("count=4096")
+            .succeeds();
+
+        scene
+            .ccmd("dd")
+            .arg("--if=/dev/zero")
+            .arg("--of=irregular-file")
+            .arg("bs=1")
+            .arg("count=777")
+            .succeeds();
+
+        scene
+            .ucmd()
+            .arg("-l")
+            .arg("--block-size=512")
+            .arg("irregular-file")
+            .succeeds()
+            .stdout_matches(&Regex::new("[^ ] 2 [^ ]").unwrap());
+
+        scene
+            .ucmd()
+            .arg("-s1")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_is("total 4096\n   0 empty-file\n   0 file-with-holes\n4096 zero-file\n");
+
+        scene
+            .ucmd()
+            .arg("-sl")
+            .arg("some-dir1")
+            .succeeds()
+            // block size is 0 whereas size/len is 4194304
+            .stdout_contains("4194304");
+
+        scene
+            .ucmd()
+            .arg("-s1")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("0 empty-file")
+            .stdout_contains("4096 zero-file");
+
+        // Test alignment of different block sized files
+        let res = scene.ucmd().arg("-si1").arg("some-dir1").succeeds();
+
+        let empty_file_len = String::from_utf8(res.stdout().to_owned())
+            .ok()
+            .unwrap()
+            .lines()
+            .nth(1)
+            .unwrap()
+            .strip_suffix("empty-file")
+            .unwrap()
+            .len();
+
+        let file_with_holes_len = String::from_utf8(res.stdout().to_owned())
+            .ok()
+            .unwrap()
+            .lines()
+            .nth(2)
+            .unwrap()
+            .strip_suffix("file-with-holes")
+            .unwrap()
+            .len();
+
+        assert_eq!(empty_file_len, file_with_holes_len);
+
+        scene
+            .ucmd()
+            .env("LS_BLOCK_SIZE", "8K")
+            .env("BLOCK_SIZE", "4K")
+            .arg("-s1")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 512")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("512 zero-file");
+
+        scene
+            .ucmd()
+            .env("BLOCK_SIZE", "4K")
+            .arg("-s1")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 1024")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("1024 zero-file");
+
+        scene
+            .ucmd()
+            .env("BLOCK_SIZE", "4K")
+            .arg("-s1")
+            .arg("--si")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 4.2M")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("4.2M zero-file");
+
+        scene
+            .ucmd()
+            .env("BLOCK_SIZE", "4096")
+            .arg("-s1")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 1024")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("1024 zero-file");
+
+        scene
+            .ucmd()
+            .env("POSIXLY_CORRECT", "true")
+            .arg("-s1")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 8192")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("8192 zero-file");
+
+        // -k should make 'ls' ignore the env var
+        scene
+            .ucmd()
+            .env("BLOCK_SIZE", "4K")
+            .arg("-s1k")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 4096")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("4096 zero-file");
+
+        // but manually specified blocksize overrides -k
+        scene
+            .ucmd()
+            .arg("-s1k")
+            .arg("--block-size=4K")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 1024")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("1024 zero-file");
+
+        scene
+            .ucmd()
+            .arg("-s1")
+            .arg("--block-size=4K")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 1024")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("1024 zero-file");
+
+        // si option should always trump the human-readable option
+        scene
+            .ucmd()
+            .arg("-s1h")
+            .arg("--si")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 4.2M")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("4.2M zero-file");
+
+        scene
+            .ucmd()
+            .arg("-s1")
+            .arg("--block-size=human-readable")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 4.0M")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("4.0M zero-file");
+
+        scene
+            .ucmd()
+            .arg("-s1")
+            .arg("--block-size=si")
+            .arg("some-dir1")
+            .succeeds()
+            .stdout_contains("total 4.2M")
+            .stdout_contains("0 empty-file")
+            .stdout_contains("0 file-with-holes")
+            .stdout_contains("4.2M zero-file");
+    }
+}
+
+#[test]
+fn test_ls_devices() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("some-dir1");
+
+    // Regex tests correct device ID and correct (no pad) spacing for a single file
+    #[cfg(any(target_os = "macos", target_os = "ios"))]
+    {
+        scene
+            .ucmd()
+            .arg("-al")
+            .arg("/dev/null")
+            .succeeds()
+            .stdout_matches(&Regex::new("[^ ] 3, 2 [^ ]").unwrap());
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        scene
+            .ucmd()
+            .arg("-al")
+            .arg("/dev/null")
+            .succeeds()
+            .stdout_matches(&Regex::new("[^ ] 1, 3 [^ ]").unwrap());
+    }
+
+    // Tests display alignment against a file (stdout is a link to a tty)
+    #[cfg(unix)]
+    {
+        let res = scene
+            .ucmd()
+            .arg("-alL")
+            .arg("/dev/null")
+            .arg("/dev/stdout")
+            .succeeds();
+
+        let null_len = String::from_utf8(res.stdout().to_owned())
+            .ok()
+            .unwrap()
+            .lines()
+            .next()
+            .unwrap()
+            .strip_suffix("/dev/null")
+            .unwrap()
+            .len();
+
+        let stdout_len = String::from_utf8(res.stdout().to_owned())
+            .ok()
+            .unwrap()
+            .lines()
+            .nth(1)
+            .unwrap()
+            .strip_suffix("/dev/stdout")
+            .unwrap()
+            .len();
+
+        assert_eq!(stdout_len, null_len);
+    }
+}
+
+#[cfg(feature = "chmod")]
+#[test]
+fn test_ls_io_errors() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("some-dir1");
+    at.mkdir("some-dir2");
+    at.symlink_file("does_not_exist", "some-dir2/dangle");
+    at.mkdir("some-dir3");
+    at.mkdir("some-dir3/some-dir4");
+    at.mkdir("some-dir4");
+
+    scene.ccmd("chmod").arg("000").arg("some-dir1").succeeds();
+
+    scene
+        .ucmd()
+        .arg("-1")
+        .arg("some-dir1")
+        .fails()
+        .stderr_contains("cannot open directory")
+        .stderr_contains("Permission denied");
+
+    scene
+        .ucmd()
+        .arg("-Li")
+        .arg("some-dir2")
+        .fails()
+        .stderr_contains("cannot access")
+        .stderr_contains("No such file or directory")
+        .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
+
+    scene
+        .ccmd("chmod")
+        .arg("000")
+        .arg("some-dir3/some-dir4")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-laR")
+        .arg("some-dir3")
+        .fails()
+        .stderr_contains("some-dir4")
+        .stderr_contains("cannot open directory")
+        .stderr_contains("Permission denied")
+        .stdout_contains("some-dir4");
+
+    // don't double print on dangling link metadata errors
+    scene
+        .ucmd()
+        .arg("-iRL")
+        .arg("some-dir2")
+        .fails()
+        .stderr_does_not_contain(
+            "ls: cannot access 'some-dir2/dangle': No such file or directory\nls: cannot access 'some-dir2/dangle': No such file or directory"
+        );
+
+    #[cfg(unix)]
+    {
+        at.touch("some-dir4/bad-fd.txt");
+        let fd1 = at.open("some-dir4/bad-fd.txt").into_raw_fd();
+        let fd2 = dup(dbg!(fd1)).unwrap();
+        close(fd1).unwrap();
+
+        // on the mac and in certain Linux containers bad fds are typed as dirs,
+        // however sometimes bad fds are typed as links and directory entry on links won't fail
+        if PathBuf::from(format!("/dev/fd/{fd}", fd = fd2)).is_dir() {
+            scene
+                .ucmd()
+                .arg("-alR")
+                .arg(format!("/dev/fd/{fd}", fd = fd2))
+                .fails()
+                .stderr_contains(format!(
+                    "cannot open directory '/dev/fd/{fd}': Bad file descriptor",
+                    fd = fd2
+                ))
+                .stdout_does_not_contain(format!("{fd}:\n", fd = fd2));
+
+            scene
+                .ucmd()
+                .arg("-RiL")
+                .arg(format!("/dev/fd/{fd}", fd = fd2))
+                .fails()
+                .stderr_contains(format!("cannot open directory '/dev/fd/{fd}': Bad file descriptor", fd = fd2))
+                // don't double print bad fd errors
+                .stderr_does_not_contain(format!("ls: cannot open directory '/dev/fd/{fd}': Bad file descriptor\nls: cannot open directory '/dev/fd/{fd}': Bad file descriptor", fd = fd2));
+        } else {
+            scene
+                .ucmd()
+                .arg("-alR")
+                .arg(format!("/dev/fd/{fd}", fd = fd2))
+                .succeeds();
+
+            scene
+                .ucmd()
+                .arg("-RiL")
+                .arg(format!("/dev/fd/{fd}", fd = fd2))
+                .succeeds();
+        }
+
+        scene
+            .ucmd()
+            .arg("-alL")
+            .arg(format!("/dev/fd/{fd}", fd = fd2))
+            .succeeds();
+
+        let _ = close(fd2);
+    }
+}
+
+#[test]
+fn test_ls_only_dirs_formatting() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("some-dir1");
+    at.mkdir("some-dir2");
+    at.mkdir("some-dir3");
+
+    #[cfg(unix)]
+    {
+        scene.ucmd().arg("-1").arg("-R").succeeds().stdout_only(
+            ".:\nsome-dir1\nsome-dir2\nsome-dir3\n\n./some-dir1:\n\n./some-dir2:\n\n./some-dir3:\n",
+        );
+    }
+    #[cfg(windows)]
+    {
+        scene.ucmd().arg("-1").arg("-R").succeeds().stdout_only(
+            ".:\nsome-dir1\nsome-dir2\nsome-dir3\n\n.\\some-dir1:\n\n.\\some-dir2:\n\n.\\some-dir3:\n",
+        );
+    }
+}
+
+#[test]
+fn test_ls_walk_glob() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch(".test-1");
+    at.mkdir("some-dir");
+    at.touch(
+        Path::new("some-dir")
+            .join("test-2~")
+            .as_os_str()
+            .to_str()
+            .unwrap(),
+    );
+
+    #[allow(clippy::trivial_regex)]
+    let re_pwd = Regex::new(r"^\.\n").unwrap();
+
+    scene
+        .ucmd()
+        .arg("-1")
+        .arg("--ignore-backups")
+        .arg("some-dir")
+        .succeeds()
+        .stdout_does_not_contain("test-2~")
+        .stdout_does_not_contain("..")
+        .stdout_does_not_match(&re_pwd);
+}
+
+#[test]
+#[cfg(unix)]
 fn test_ls_a() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -124,7 +604,13 @@ fn test_ls_width() {
     at.touch(&at.plus_as_string("test-width-3"));
     at.touch(&at.plus_as_string("test-width-4"));
 
-    for option in &["-w 100", "-w=100", "--width=100", "--width 100"] {
+    for option in &[
+        "-w 100",
+        "-w=100",
+        "--width=100",
+        "--width 100",
+        "--wid=100",
+    ] {
         scene
             .ucmd()
             .args(&option.split(' ').collect::<Vec<_>>())
@@ -133,7 +619,7 @@ fn test_ls_width() {
             .stdout_only("test-width-1  test-width-2  test-width-3  test-width-4\n");
     }
 
-    for option in &["-w 50", "-w=50", "--width=50", "--width 50"] {
+    for option in &["-w 50", "-w=50", "--width=50", "--width 50", "--wid=50"] {
         scene
             .ucmd()
             .args(&option.split(' ').collect::<Vec<_>>())
@@ -142,7 +628,7 @@ fn test_ls_width() {
             .stdout_only("test-width-1  test-width-3\ntest-width-2  test-width-4\n");
     }
 
-    for option in &["-w 25", "-w=25", "--width=25", "--width 25"] {
+    for option in &["-w 25", "-w=25", "--width=25", "--width 25", "--wid=25"] {
         scene
             .ucmd()
             .args(&option.split(' ').collect::<Vec<_>>())
@@ -151,7 +637,7 @@ fn test_ls_width() {
             .stdout_only("test-width-1\ntest-width-2\ntest-width-3\ntest-width-4\n");
     }
 
-    for option in &["-w 0", "-w=0", "--width=0", "--width 0"] {
+    for option in &["-w 0", "-w=0", "--width=0", "--width 0", "--wid=0"] {
         scene
             .ucmd()
             .args(&option.split(' ').collect::<Vec<_>>())
@@ -167,7 +653,7 @@ fn test_ls_width() {
         .fails()
         .stderr_contains("invalid line width");
 
-    for option in &["-w 1a", "-w=1a", "--width=1a", "--width 1a"] {
+    for option in &["-w 1a", "-w=1a", "--width=1a", "--width 1a", "--wid 1a"] {
         scene
             .ucmd()
             .args(&option.split(' ').collect::<Vec<_>>())
@@ -191,12 +677,12 @@ fn test_ls_columns() {
 
     result.stdout_only("test-columns-1\ntest-columns-2\ntest-columns-3\ntest-columns-4\n");
 
-    for option in &["-C", "--format=columns"] {
+    for option in COLUMN_ARGS {
         let result = scene.ucmd().arg(option).succeeds();
         result.stdout_only("test-columns-1  test-columns-2  test-columns-3  test-columns-4\n");
     }
 
-    for option in &["-C", "--format=columns"] {
+    for option in COLUMN_ARGS {
         scene
             .ucmd()
             .arg("-w=40")
@@ -209,7 +695,7 @@ fn test_ls_columns() {
     // environment variable.
     #[cfg(not(windows))]
     {
-        for option in &["-C", "--format=columns"] {
+        for option in COLUMN_ARGS {
             scene
                 .ucmd()
                 .env("COLUMNS", "40")
@@ -247,14 +733,14 @@ fn test_ls_across() {
     at.touch(&at.plus_as_string("test-across-3"));
     at.touch(&at.plus_as_string("test-across-4"));
 
-    for option in &["-x", "--format=across"] {
+    for option in ACROSS_ARGS {
         let result = scene.ucmd().arg(option).succeeds();
         // Because the test terminal has width 0, this is the same output as
         // the columns option.
         result.stdout_only("test-across-1  test-across-2  test-across-3  test-across-4\n");
     }
 
-    for option in &["-x", "--format=across"] {
+    for option in ACROSS_ARGS {
         // Because the test terminal has width 0, this is the same output as
         // the columns option.
         scene
@@ -275,12 +761,12 @@ fn test_ls_commas() {
     at.touch(&at.plus_as_string("test-commas-3"));
     at.touch(&at.plus_as_string("test-commas-4"));
 
-    for option in &["-m", "--format=commas"] {
+    for option in COMMA_ARGS {
         let result = scene.ucmd().arg(option).succeeds();
         result.stdout_only("test-commas-1, test-commas-2, test-commas-3, test-commas-4\n");
     }
 
-    for option in &["-m", "--format=commas"] {
+    for option in COMMA_ARGS {
         scene
             .ucmd()
             .arg("-w=30")
@@ -288,7 +774,7 @@ fn test_ls_commas() {
             .succeeds()
             .stdout_only("test-commas-1, test-commas-2,\ntest-commas-3, test-commas-4\n");
     }
-    for option in &["-m", "--format=commas"] {
+    for option in COMMA_ARGS {
         scene
             .ucmd()
             .arg("-w=45")
@@ -300,37 +786,18 @@ fn test_ls_commas() {
 
 #[test]
 fn test_ls_long() {
-    #[cfg(not(windows))]
-    let last;
-    #[cfg(not(windows))]
-    {
-        let _guard = UMASK_MUTEX.lock();
-        last = unsafe { umask(0) };
-
-        unsafe {
-            umask(0o002);
-        }
-    }
-
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
     at.touch(&at.plus_as_string("test-long"));
 
-    for arg in &["-l", "--long", "--format=long", "--format=verbose"] {
+    for arg in LONG_ARGS {
         let result = scene.ucmd().arg(arg).arg("test-long").succeeds();
         #[cfg(not(windows))]
-        result.stdout_contains("-rw-rw-r--");
+        result.stdout_matches(&Regex::new(r"[-bcCdDlMnpPsStTx?]([r-][w-][xt-]){3}.*").unwrap());
 
         #[cfg(windows)]
         result.stdout_contains("---------- 1 somebody somegroup");
     }
-
-    #[cfg(not(windows))]
-    {
-        unsafe {
-            umask(last);
-        }
-    }
 }
 
 #[cfg(not(windows))]
@@ -342,7 +809,7 @@ fn test_ls_long_format() {
     at.touch(&at.plus_as_string("test-long-dir/test-long-file"));
     at.mkdir(&at.plus_as_string("test-long-dir/test-long-dir"));
 
-    for arg in &["-l", "--long", "--format=long", "--format=verbose"] {
+    for arg in LONG_ARGS {
         // Assuming sane username do not have spaces within them.
         // A line of the output should be:
         // One of the characters -bcCdDlMnpPsStTx?
@@ -617,7 +1084,7 @@ fn test_ls_long_total_size() {
         .collect()
     };
 
-    for arg in &["-l", "--long", "--format=long", "--format=verbose"] {
+    for arg in LONG_ARGS {
         let result = scene.ucmd().arg(arg).succeeds();
         result.stdout_contains(expected_prints["long_vanilla"]);
 
@@ -1072,17 +1539,14 @@ fn test_ls_order_time() {
     // So the order should be 2 3 4 1
     for arg in &["-u", "--time=atime", "--time=access", "--time=use"] {
         let result = scene.ucmd().arg("-t").arg(arg).succeeds();
-        let file3_access = at.open("test-3").metadata().unwrap().accessed().unwrap();
-        let file4_access = at.open("test-4").metadata().unwrap().accessed().unwrap();
+        at.open("test-3").metadata().unwrap().accessed().unwrap();
+        at.open("test-4").metadata().unwrap().accessed().unwrap();
 
         // It seems to be dependent on the platform whether the access time is actually set
-        if file3_access > file4_access {
-            result.stdout_only("test-3\ntest-4\ntest-2\ntest-1\n");
-        } else {
-            // Access time does not seem to be set on Windows and some other
-            // systems so the order is 4 3 2 1
-            result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
-        }
+        #[cfg(unix)]
+        result.stdout_only("test-3\ntest-4\ntest-2\ntest-1\n");
+        #[cfg(windows)]
+        result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
     }
 
     // test-2 had the last ctime change when the permissions were set
@@ -1192,20 +1656,14 @@ fn test_ls_color() {
     assert!(!result.stdout_str().contains(z_with_colors));
 
     // Color should be enabled
-    scene
-        .ucmd()
-        .arg("--color")
-        .succeeds()
-        .stdout_contains(a_with_colors)
-        .stdout_contains(z_with_colors);
-
-    // Color should be enabled
-    scene
-        .ucmd()
-        .arg("--color=always")
-        .succeeds()
-        .stdout_contains(a_with_colors)
-        .stdout_contains(z_with_colors);
+    for param in &["--color", "--col", "--color=always", "--col=always"] {
+        scene
+            .ucmd()
+            .arg(param)
+            .succeeds()
+            .stdout_contains(a_with_colors)
+            .stdout_contains(z_with_colors);
+    }
 
     // Color should be disabled
     let result = scene.ucmd().arg("--color=never").succeeds();
@@ -1280,7 +1738,7 @@ fn test_ls_inode() {
     assert!(!re_long.is_match(result.stdout_str()));
     assert!(!result.stdout_str().contains(inode_long));
 
-    assert_eq!(inode_short, inode_long)
+    assert_eq!(inode_short, inode_long);
 }
 
 #[test]
@@ -1301,24 +1759,42 @@ fn test_ls_indicator_style() {
     assert!(at.is_fifo("named-pipe.fifo"));
 
     // Classify, File-Type, and Slash all contain indicators for directories.
-    let options = vec!["classify", "file-type", "slash"];
-    for opt in options {
+    for opt in [
+        "--indicator-style=classify",
+        "--ind=classify",
+        "--indicator-style=file-type",
+        "--ind=file-type",
+        "--indicator-style=slash",
+        "--ind=slash",
+        "--classify",
+        "--classify=always",
+        "--classify=yes",
+        "--classify=force",
+        "--class",
+        "--file-type",
+        "--file",
+        "-p",
+    ] {
         // Verify that classify and file-type both contain indicators for symlinks.
-        scene
-            .ucmd()
-            .arg(format!("--indicator-style={}", opt))
-            .succeeds()
-            .stdout_contains(&"/");
+        scene.ucmd().arg(opt).succeeds().stdout_contains(&"/");
     }
 
-    // Same test as above, but with the alternate flags.
-    let options = vec!["--classify", "--file-type", "-p"];
-    for opt in options {
+    // Classify, Indicator options should not contain any indicators when value is none.
+    for opt in [
+        "--indicator-style=none",
+        "--ind=none",
+        "--classify=none",
+        "--classify=never",
+        "--classify=no",
+    ] {
+        // Verify that there are no indicators for any of the file types.
         scene
             .ucmd()
-            .arg(opt.to_string())
+            .arg(opt)
             .succeeds()
-            .stdout_contains(&"/");
+            .stdout_does_not_contain(&"/")
+            .stdout_does_not_contain(&"@")
+            .stdout_does_not_contain(&"|");
     }
 
     // Classify and File-Type all contain indicators for pipes and links.
@@ -1385,11 +1861,7 @@ fn test_ls_indicator_style() {
     // Same test as above, but with the alternate flags.
     let options = vec!["--classify", "--file-type", "-p"];
     for opt in options {
-        scene
-            .ucmd()
-            .arg(opt.to_string())
-            .succeeds()
-            .stdout_contains(&"/");
+        scene.ucmd().arg(opt).succeeds().stdout_contains(&"/");
     }
 
     // Classify and File-Type all contain indicators for pipes and links.
@@ -1523,6 +1995,41 @@ fn test_ls_hidden_windows() {
     scene.ucmd().arg("-a").succeeds().stdout_contains(file);
 }
 
+#[cfg(windows)]
+#[test]
+fn test_ls_hidden_link_windows() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file = "visibleWindowsFileNoDot";
+    at.touch(file);
+
+    let link = "hiddenWindowsLinkNoDot";
+    at.symlink_dir(file, link);
+    // hide the link
+    scene.cmd("attrib").arg("/l").arg("+h").arg(link).succeeds();
+
+    scene
+        .ucmd()
+        .succeeds()
+        .stdout_contains(file)
+        .stdout_does_not_contain(link);
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .succeeds()
+        .stdout_contains(file)
+        .stdout_contains(link);
+}
+
+#[cfg(windows)]
+#[test]
+fn test_ls_success_on_c_drv_root_windows() {
+    let scene = TestScenario::new(util_name!());
+    scene.ucmd().arg("C:\\").succeeds();
+}
+
 #[test]
 fn test_ls_version_sort() {
     let scene = TestScenario::new(util_name!());
@@ -1598,7 +2105,7 @@ fn test_ls_version_sort() {
     assert_eq!(
         result.stdout_str().split('\n').collect::<Vec<_>>(),
         expected,
-    )
+    );
 }
 
 #[test]
@@ -1769,48 +2276,42 @@ fn test_ls_ignore_hide() {
 
     scene
         .ucmd()
-        .arg("--hide")
-        .arg("*")
+        .arg("--hide=*")
         .arg("-1")
         .succeeds()
         .stdout_only("");
 
     scene
         .ucmd()
-        .arg("--ignore")
-        .arg("*")
+        .arg("--ignore=*")
         .arg("-1")
         .succeeds()
         .stdout_only("");
 
     scene
         .ucmd()
-        .arg("--ignore")
-        .arg("irrelevant pattern")
+        .arg("--ignore=irrelevant pattern")
         .arg("-1")
         .succeeds()
         .stdout_only("CONTRIBUTING.md\nREADME.md\nREADMECAREFULLY.md\nsome_other_file\n");
 
     scene
         .ucmd()
-        .arg("--ignore")
-        .arg("README*.md")
+        .arg("--ignore=README*.md")
         .arg("-1")
         .succeeds()
         .stdout_only("CONTRIBUTING.md\nsome_other_file\n");
 
     scene
         .ucmd()
-        .arg("--hide")
-        .arg("README*.md")
+        .arg("--hide=README*.md")
         .arg("-1")
         .succeeds()
         .stdout_only("CONTRIBUTING.md\nsome_other_file\n");
 
     scene
         .ucmd()
-        .arg("--ignore")
-        .arg("*.md")
+        .arg("--ignore=*.md")
         .arg("-1")
         .succeeds()
         .stdout_only("some_other_file\n");
@@ -1818,8 +2319,7 @@ fn test_ls_ignore_hide() {
     scene
         .ucmd()
         .arg("-a")
-        .arg("--ignore")
-        .arg("*.md")
+        .arg("--ignore=*.md")
         .arg("-1")
         .succeeds()
         .stdout_only(".\n..\nsome_other_file\n");
@@ -1827,8 +2327,7 @@ fn test_ls_ignore_hide() {
     scene
         .ucmd()
         .arg("-a")
-        .arg("--hide")
-        .arg("*.md")
+        .arg("--hide=*.md")
         .arg("-1")
         .succeeds()
         .stdout_only(".\n..\nCONTRIBUTING.md\nREADME.md\nREADMECAREFULLY.md\nsome_other_file\n");
@@ -1836,8 +2335,7 @@ fn test_ls_ignore_hide() {
     scene
         .ucmd()
         .arg("-A")
-        .arg("--ignore")
-        .arg("*.md")
+        .arg("--ignore=*.md")
         .arg("-1")
         .succeeds()
         .stdout_only("some_other_file\n");
@@ -1845,8 +2343,7 @@ fn test_ls_ignore_hide() {
     scene
         .ucmd()
         .arg("-A")
-        .arg("--hide")
-        .arg("*.md")
+        .arg("--hide=*.md")
         .arg("-1")
         .succeeds()
         .stdout_only("CONTRIBUTING.md\nREADME.md\nREADMECAREFULLY.md\nsome_other_file\n");
@@ -1854,30 +2351,24 @@ fn test_ls_ignore_hide() {
     // Stacking multiple patterns
     scene
         .ucmd()
-        .arg("--ignore")
-        .arg("README*")
-        .arg("--ignore")
-        .arg("CONTRIBUTING*")
+        .arg("--ignore=README*")
+        .arg("--ignore=CONTRIBUTING*")
         .arg("-1")
         .succeeds()
         .stdout_only("some_other_file\n");
 
     scene
         .ucmd()
-        .arg("--hide")
-        .arg("README*")
-        .arg("--ignore")
-        .arg("CONTRIBUTING*")
+        .arg("--hide=README*")
+        .arg("--ignore=CONTRIBUTING*")
         .arg("-1")
         .succeeds()
         .stdout_only("some_other_file\n");
 
     scene
         .ucmd()
-        .arg("--hide")
-        .arg("README*")
-        .arg("--hide")
-        .arg("CONTRIBUTING*")
+        .arg("--hide=README*")
+        .arg("--hide=CONTRIBUTING*")
         .arg("-1")
         .succeeds()
         .stdout_only("some_other_file\n");
@@ -1885,8 +2376,7 @@ fn test_ls_ignore_hide() {
     // Invalid patterns
     scene
         .ucmd()
-        .arg("--ignore")
-        .arg("READ[ME")
+        .arg("--ignore=READ[ME")
         .arg("-1")
         .succeeds()
         .stderr_contains(&"Invalid pattern")
@@ -1894,8 +2384,7 @@ fn test_ls_ignore_hide() {
 
     scene
         .ucmd()
-        .arg("--hide")
-        .arg("READ[ME")
+        .arg("--hide=READ[ME")
         .arg("-1")
         .succeeds()
         .stderr_contains(&"Invalid pattern")
@@ -1903,6 +2392,7 @@ fn test_ls_ignore_hide() {
 }
 
 #[test]
+#[cfg(unix)]
 fn test_ls_ignore_backups() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -2273,8 +2763,47 @@ fn test_ls_dangling_symlinks() {
         .ucmd()
         .arg("-Li")
         .arg("temp_dir")
-        .succeeds() // this should fail, though at the moment, ls lacks a way to propagate errors encountered during display
+        .fails()
+        .stderr_contains("cannot access")
+        .stderr_contains("No such file or directory")
         .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
+
+    scene
+        .ucmd()
+        .arg("-Ll")
+        .arg("temp_dir")
+        .fails()
+        .stdout_contains("l?????????");
+
+    #[cfg(unix)]
+    {
+        // Check padding is the same for real files and dangling links, in non-long formats
+        at.touch("temp_dir/real_file");
+
+        let real_file_res = scene.ucmd().arg("-Li1").arg("temp_dir").fails();
+        let real_file_stdout_len = String::from_utf8(real_file_res.stdout().to_owned())
+            .ok()
+            .unwrap()
+            .lines()
+            .nth(1)
+            .unwrap()
+            .strip_suffix("real_file")
+            .unwrap()
+            .len();
+
+        let dangle_file_res = scene.ucmd().arg("-Li1").arg("temp_dir").fails();
+        let dangle_stdout_len = String::from_utf8(dangle_file_res.stdout().to_owned())
+            .ok()
+            .unwrap()
+            .lines()
+            .next()
+            .unwrap()
+            .strip_suffix("dangle")
+            .unwrap()
+            .len();
+
+        assert_eq!(real_file_stdout_len, dangle_stdout_len);
+    }
 }
 
 #[test]
@@ -2306,7 +2835,7 @@ fn test_ls_context2() {
         ts.ucmd()
             .args(&[c_flag, &"/"])
             .succeeds()
-            .stdout_only(unwrap_or_return!(expected_result(&ts, &[c_flag, &"/"])).stdout_str());
+            .stdout_only(unwrap_or_return!(expected_result(&ts, &[c_flag, "/"])).stdout_str());
     }
 }
 
@@ -2336,8 +2865,90 @@ fn test_ls_context_format() {
             .args(&[&"-Z", &format.as_str(), &"/"])
             .succeeds()
             .stdout_only(
-                unwrap_or_return!(expected_result(&ts, &[&"-Z", &format.as_str(), &"/"]))
-                    .stdout_str(),
+                unwrap_or_return!(expected_result(&ts, &["-Z", format.as_str(), "/"])).stdout_str(),
             );
     }
 }
+
+#[test]
+#[allow(non_snake_case)]
+fn test_ls_a_A() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .arg("-A")
+        .arg("-a")
+        .succeeds()
+        .stdout_contains(".")
+        .stdout_contains("..");
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("-A")
+        .succeeds()
+        .stdout_does_not_contain(".")
+        .stdout_does_not_contain("..");
+}
+
+#[test]
+#[allow(non_snake_case)]
+fn test_ls_multiple_a_A() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("-a")
+        .succeeds()
+        .stdout_contains(".")
+        .stdout_contains("..");
+
+    scene
+        .ucmd()
+        .arg("-A")
+        .arg("-A")
+        .succeeds()
+        .stdout_does_not_contain(".")
+        .stdout_does_not_contain("..");
+}
+
+#[test]
+fn test_ls_quoting() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("ln")
+        .arg("-s")
+        .arg("'need quoting'")
+        .arg("symlink")
+        .succeeds();
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--quoting-style=shell-escape")
+        .arg("symlink")
+        .succeeds()
+        .stdout_contains("\'need quoting\'");
+}
+
+#[test]
+fn test_ls_quoting_color() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("ln")
+        .arg("-s")
+        .arg("'need quoting'")
+        .arg("symlink")
+        .succeeds();
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--quoting-style=shell-escape")
+        .arg("--color=auto")
+        .arg("symlink")
+        .succeeds()
+        .stdout_contains("\'need quoting\'");
+}
diff --git a/tests/by-util/test_mkdir.rs b/tests/by-util/test_mkdir.rs
index f3451fb5e..675ca6bea 100644
--- a/tests/by-util/test_mkdir.rs
+++ b/tests/by-util/test_mkdir.rs
@@ -9,6 +9,10 @@ static TEST_DIR4: &str = "mkdir_test4/mkdir_test4_1";
 static TEST_DIR5: &str = "mkdir_test5/mkdir_test5_1";
 static TEST_DIR6: &str = "mkdir_test6";
 static TEST_FILE7: &str = "mkdir_test7";
+static TEST_DIR8: &str = "mkdir_test8/mkdir_test8_1/mkdir_test8_2";
+static TEST_DIR9: &str = "mkdir_test9/../mkdir_test9_1/../mkdir_test9_2";
+static TEST_DIR10: &str = "mkdir_test10/.";
+static TEST_DIR11: &str = "mkdir_test11/..";
 
 #[test]
 fn test_mkdir_mkdir() {
@@ -75,7 +79,7 @@ fn test_symbolic_mode() {
 
     ucmd.arg("-m").arg("a=rwx").arg(TEST_DIR1).succeeds();
     let perms = at.metadata(TEST_DIR1).permissions().mode();
-    assert_eq!(perms, 0o40777)
+    assert_eq!(perms, 0o40777);
 }
 
 #[test]
@@ -85,7 +89,7 @@ fn test_symbolic_alteration() {
 
     ucmd.arg("-m").arg("-w").arg(TEST_DIR1).succeeds();
     let perms = at.metadata(TEST_DIR1).permissions().mode();
-    assert_eq!(perms, 0o40555)
+    assert_eq!(perms, 0o40555);
 }
 
 #[test]
@@ -98,5 +102,52 @@ fn test_multi_symbolic() {
         .arg(TEST_DIR1)
         .succeeds();
     let perms = at.metadata(TEST_DIR1).permissions().mode();
-    assert_eq!(perms, 0o40750)
+    assert_eq!(perms, 0o40750);
+}
+
+#[test]
+fn test_recursive_reporting() {
+    new_ucmd!()
+        .arg("-p")
+        .arg("-v")
+        .arg(TEST_DIR8)
+        .succeeds()
+        .stdout_contains("created directory 'mkdir_test8'")
+        .stdout_contains("created directory 'mkdir_test8/mkdir_test8_1'")
+        .stdout_contains("created directory 'mkdir_test8/mkdir_test8_1/mkdir_test8_2'");
+    new_ucmd!().arg("-v").arg(TEST_DIR8).fails().no_stdout();
+    new_ucmd!()
+        .arg("-p")
+        .arg("-v")
+        .arg(TEST_DIR9)
+        .succeeds()
+        .stdout_contains("created directory 'mkdir_test9'")
+        .stdout_contains("created directory 'mkdir_test9/../mkdir_test9_1'")
+        .stdout_contains("created directory 'mkdir_test9/../mkdir_test9_1/../mkdir_test9_2'");
+}
+
+#[test]
+fn test_mkdir_trailing_dot() {
+    let scene2 = TestScenario::new("ls");
+    new_ucmd!()
+        .arg("-p")
+        .arg("-v")
+        .arg("mkdir_test10-2")
+        .succeeds();
+
+    new_ucmd!()
+        .arg("-p")
+        .arg("-v")
+        .arg(TEST_DIR10)
+        .succeeds()
+        .stdout_contains("created directory 'mkdir_test10'");
+
+    new_ucmd!()
+        .arg("-p")
+        .arg("-v")
+        .arg(TEST_DIR11)
+        .succeeds()
+        .stdout_contains("created directory 'mkdir_test11'");
+    let result = scene2.cmd("ls").arg("-al").run();
+    println!("ls dest {}", result.stdout_str());
 }
diff --git a/tests/by-util/test_mknod.rs b/tests/by-util/test_mknod.rs
index 1d39372ac..3b22ef835 100644
--- a/tests/by-util/test_mknod.rs
+++ b/tests/by-util/test_mknod.rs
@@ -86,16 +86,14 @@ fn test_mknod_character_device_requires_major_and_minor() {
         .arg("1")
         .arg("c")
         .fails()
-        .status_code(1)
-        .stderr_contains(&"Invalid value for '<MINOR>'");
+        .stderr_contains(&"Invalid value \"c\" for '<MINOR>'");
     new_ucmd!()
         .arg("test_file")
         .arg("c")
         .arg("c")
         .arg("1")
         .fails()
-        .status_code(1)
-        .stderr_contains(&"Invalid value for '<MAJOR>'");
+        .stderr_contains(&"Invalid value \"c\" for '<MAJOR>'");
 }
 
 #[test]
@@ -104,7 +102,6 @@ fn test_mknod_invalid_arg() {
     new_ucmd!()
         .arg("--foo")
         .fails()
-        .status_code(1)
         .no_stdout()
         .stderr_contains(&"Found argument '--foo' which wasn't expected");
 }
diff --git a/tests/by-util/test_more.rs b/tests/by-util/test_more.rs
index 4b2719d8f..5c2b3c0f6 100644
--- a/tests/by-util/test_more.rs
+++ b/tests/by-util/test_more.rs
@@ -15,15 +15,10 @@ fn test_more_dir_arg() {
     // Maybe we could capture the error, i.e. "Device not found" in that case
     // but I am leaving this for later
     if atty::is(atty::Stream::Stdout) {
-        let ts = TestScenario::new(util_name!());
-        let result = ts.ucmd().arg(".").run();
-        result.failure();
-        let expected_error_message = &format!(
-            "{0}: '.' is a directory.\nTry '{1} {0} --help' for more information.",
-            ts.util_name,
-            ts.bin_path.to_string_lossy()
-        );
-        assert_eq!(result.stderr_str().trim(), expected_error_message);
+        new_ucmd!()
+            .arg(".")
+            .fails()
+            .usage_error("'.' is a directory.");
     } else {
     }
 }
diff --git a/tests/by-util/test_mv.rs b/tests/by-util/test_mv.rs
index 8d9b00664..a0bd0209d 100644
--- a/tests/by-util/test_mv.rs
+++ b/tests/by-util/test_mv.rs
@@ -232,6 +232,40 @@ fn test_mv_force_replace_file() {
     assert!(at.file_exists(file_b));
 }
 
+#[test]
+fn test_mv_same_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_same_file_a";
+
+    at.touch(file_a);
+    ucmd.arg(file_a).arg(file_a).fails().stderr_is(format!(
+        "mv: '{f}' and '{f}' are the same file\n",
+        f = file_a,
+    ));
+}
+
+#[test]
+fn test_mv_same_file_not_dot_dir() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir = "test_mv_errors_dir";
+
+    at.mkdir(dir);
+    ucmd.arg(dir).arg(dir).fails().stderr_is(format!(
+        "mv: cannot move '{d}' to a subdirectory of itself, '{d}/{d}'",
+        d = dir,
+    ));
+}
+
+#[test]
+fn test_mv_same_file_dot_dir() {
+    let (_at, mut ucmd) = at_and_ucmd!();
+
+    ucmd.arg(".")
+        .arg(".")
+        .fails()
+        .stderr_is("mv: '.' and '.' are the same file\n");
+}
+
 #[test]
 fn test_mv_simple_backup() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -306,6 +340,27 @@ fn test_mv_custom_backup_suffix() {
     assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
 }
 
+#[test]
+fn test_mv_custom_backup_suffix_hyphen_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_a = "test_mv_custom_backup_suffix_file_a";
+    let file_b = "test_mv_custom_backup_suffix_file_b";
+    let suffix = "-v";
+
+    at.touch(file_a);
+    at.touch(file_b);
+    ucmd.arg("-b")
+        .arg(format!("--suffix={}", suffix))
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(!at.file_exists(file_a));
+    assert!(at.file_exists(file_b));
+    assert!(at.file_exists(&format!("{}{}", file_b, suffix)));
+}
+
 #[test]
 fn test_mv_custom_backup_suffix_via_env() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -522,17 +577,13 @@ fn test_mv_backup_off() {
 
 #[test]
 fn test_mv_backup_no_clobber_conflicting_options() {
-    let ts = TestScenario::new(util_name!());
-
-    ts.ucmd().arg("--backup")
+    new_ucmd!()
+        .arg("--backup")
         .arg("--no-clobber")
         .arg("file1")
         .arg("file2")
         .fails()
-        .stderr_is(&format!("{0}: options --backup and --no-clobber are mutually exclusive\nTry '{1} {0} --help' for more information.",
-            ts.util_name,
-            ts.bin_path.to_string_lossy()
-        ));
+        .usage_error("options --backup and --no-clobber are mutually exclusive");
 }
 
 #[test]
diff --git a/tests/by-util/test_nice.rs b/tests/by-util/test_nice.rs
index 7a99a333d..4a77ae24e 100644
--- a/tests/by-util/test_nice.rs
+++ b/tests/by-util/test_nice.rs
@@ -22,15 +22,10 @@ fn test_negative_adjustment() {
 
 #[test]
 fn test_adjustment_with_no_command_should_error() {
-    let ts = TestScenario::new(util_name!());
-
-    ts.ucmd()
-    .args(&["-n", "19"])
-    .run()
-    .stderr_is(&format!("{0}: A command must be given with an adjustment.\nTry '{1} {0} --help' for more information.\n",
-        ts.util_name,
-        ts.bin_path.to_string_lossy()
-    ));
+    new_ucmd!()
+        .args(&["-n", "19"])
+        .fails()
+        .usage_error("A command must be given with an adjustment.");
 }
 
 #[test]
diff --git a/tests/by-util/test_nproc.rs b/tests/by-util/test_nproc.rs
index abf758829..330f327cb 100644
--- a/tests/by-util/test_nproc.rs
+++ b/tests/by-util/test_nproc.rs
@@ -1,3 +1,4 @@
+// spell-checker:ignore incorrectnumber
 use crate::common::util::*;
 
 #[test]
@@ -15,11 +16,11 @@ fn test_nproc_all_omp() {
 
     let result = TestScenario::new(util_name!())
         .ucmd_keepenv()
-        .env("OMP_NUM_THREADS", "1")
+        .env("OMP_NUM_THREADS", "60")
         .succeeds();
 
     let nproc_omp: u8 = result.stdout_str().trim().parse().unwrap();
-    assert!(nproc - 1 == nproc_omp);
+    assert_eq!(nproc_omp, 60);
 
     let result = TestScenario::new(util_name!())
         .ucmd_keepenv()
@@ -27,21 +28,141 @@ fn test_nproc_all_omp() {
         .arg("--all")
         .succeeds();
     let nproc_omp: u8 = result.stdout_str().trim().parse().unwrap();
-    assert!(nproc == nproc_omp);
+    assert_eq!(nproc, nproc_omp);
+
+    // If the parsing fails, returns the number of CPU
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "incorrectnumber") // returns the number CPU
+        .succeeds();
+    let nproc_omp: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, nproc_omp);
 }
 
 #[test]
 fn test_nproc_ignore() {
     let result = new_ucmd!().succeeds();
-    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
-    if nproc > 1 {
+    let nproc_total: u8 = result.stdout_str().trim().parse().unwrap();
+    if nproc_total > 1 {
         // Ignore all CPU but one
         let result = TestScenario::new(util_name!())
             .ucmd_keepenv()
             .arg("--ignore")
-            .arg((nproc - 1).to_string())
+            .arg((nproc_total - 1).to_string())
             .succeeds();
         let nproc: u8 = result.stdout_str().trim().parse().unwrap();
-        assert!(nproc == 1);
+        assert_eq!(nproc, 1);
+        // Ignore all CPU but one with a string
+        let result = TestScenario::new(util_name!())
+            .ucmd_keepenv()
+            .arg("--ignore= 1")
+            .succeeds();
+        let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+        assert_eq!(nproc_total - 1, nproc);
     }
 }
+
+#[test]
+fn test_nproc_ignore_all_omp() {
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "42")
+        .arg("--ignore=40")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, 2);
+}
+
+#[test]
+fn test_nproc_omp_limit() {
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "42")
+        .env("OMP_THREAD_LIMIT", "0")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, 42);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "42")
+        .env("OMP_THREAD_LIMIT", "2")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, 2);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "42")
+        .env("OMP_THREAD_LIMIT", "2bad")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, 42);
+
+    let result = new_ucmd!().arg("--all").succeeds();
+    let nproc_system: u8 = result.stdout_str().trim().parse().unwrap();
+    assert!(nproc_system > 0);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_THREAD_LIMIT", "1")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, 1);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "0")
+        .env("OMP_THREAD_LIMIT", "")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, nproc_system);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "")
+        .env("OMP_THREAD_LIMIT", "")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(nproc, nproc_system);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "2,2,1")
+        .env("OMP_THREAD_LIMIT", "")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(2, nproc);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "2,ignored")
+        .env("OMP_THREAD_LIMIT", "")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(2, nproc);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "2,2,1")
+        .env("OMP_THREAD_LIMIT", "0")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(2, nproc);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "2,2,1")
+        .env("OMP_THREAD_LIMIT", "1bad")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(2, nproc);
+
+    let result = TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .env("OMP_NUM_THREADS", "29,2,1")
+        .env("OMP_THREAD_LIMIT", "1bad")
+        .succeeds();
+    let nproc: u8 = result.stdout_str().trim().parse().unwrap();
+    assert_eq!(29, nproc);
+}
diff --git a/tests/by-util/test_numfmt.rs b/tests/by-util/test_numfmt.rs
index 336b0f7cd..0086c25e1 100644
--- a/tests/by-util/test_numfmt.rs
+++ b/tests/by-util/test_numfmt.rs
@@ -505,3 +505,91 @@ fn test_round() {
             .stdout_only(exp.join("\n") + "\n");
     }
 }
+
+#[test]
+fn test_suffix_is_added_if_not_supplied() {
+    new_ucmd!()
+        .args(&["--suffix=TEST"])
+        .pipe_in("1000")
+        .succeeds()
+        .stdout_only("1000TEST\n");
+}
+
+#[test]
+fn test_suffix_is_preserved() {
+    new_ucmd!()
+        .args(&["--suffix=TEST"])
+        .pipe_in("1000TEST")
+        .succeeds()
+        .stdout_only("1000TEST\n");
+}
+
+#[test]
+fn test_suffix_is_only_applied_to_selected_field() {
+    new_ucmd!()
+        .args(&["--suffix=TEST", "--field=2"])
+        .pipe_in("1000 2000 3000")
+        .succeeds()
+        .stdout_only("1000 2000TEST 3000\n");
+}
+
+#[test]
+fn test_transform_with_suffix_on_input() {
+    new_ucmd!()
+        .args(&["--suffix=b", "--to=si"])
+        .pipe_in("2000b")
+        .succeeds()
+        .stdout_only("2.0Kb\n");
+}
+
+#[test]
+fn test_transform_without_suffix_on_input() {
+    new_ucmd!()
+        .args(&["--suffix=b", "--to=si"])
+        .pipe_in("2000")
+        .succeeds()
+        .stdout_only("2.0Kb\n");
+}
+
+#[test]
+fn test_transform_with_suffix_and_delimiter() {
+    new_ucmd!()
+        .args(&["--suffix=b", "--to=si", "-d=|"])
+        .pipe_in("1000b|2000|3000")
+        .succeeds()
+        .stdout_only("1.0Kb|2000|3000\n");
+}
+
+#[test]
+fn test_suffix_with_padding() {
+    new_ucmd!()
+        .args(&["--suffix=pad", "--padding=12"])
+        .pipe_in("1000 2000 3000")
+        .succeeds()
+        .stdout_only("     1000pad 2000 3000\n");
+}
+
+#[test]
+fn test_invalid_stdin_number_returns_status_2() {
+    new_ucmd!().pipe_in("hello").fails().code_is(2);
+}
+
+#[test]
+fn test_invalid_stdin_number_in_middle_of_input() {
+    new_ucmd!().pipe_in("100\nhello\n200").fails().code_is(2);
+}
+
+#[test]
+fn test_invalid_argument_number_returns_status_2() {
+    new_ucmd!().args(&["hello"]).fails().code_is(2);
+}
+
+#[test]
+fn test_invalid_argument_returns_status_1() {
+    new_ucmd!()
+        .args(&["--header=hello"])
+        .pipe_in("53478")
+        .ignore_stdin_write_error()
+        .fails()
+        .code_is(1);
+}
diff --git a/tests/by-util/test_od.rs b/tests/by-util/test_od.rs
index 6c167b325..a6a81d1d6 100644
--- a/tests/by-util/test_od.rs
+++ b/tests/by-util/test_od.rs
@@ -37,7 +37,7 @@ fn test_file() {
         let mut f = File::create(&file).unwrap();
         // spell-checker:disable-next-line
         assert!(
-            !f.write_all(b"abcdefghijklmnopqrstuvwxyz\n").is_err(),
+            f.write_all(b"abcdefghijklmnopqrstuvwxyz\n").is_ok(),
             "Test setup failed - could not write file"
         );
     }
@@ -78,7 +78,7 @@ fn test_2files() {
     for &(path, data) in &[(&file1, "abcdefghijklmnop"), (&file2, "qrstuvwxyz\n")] {
         let mut f = File::create(&path).unwrap();
         assert!(
-            !f.write_all(data.as_bytes()).is_err(),
+            f.write_all(data.as_bytes()).is_ok(),
             "Test setup failed - could not write file"
         );
     }
@@ -130,7 +130,7 @@ fn test_from_mixed() {
     for &(path, data) in &[(&file1, data1), (&file3, data3)] {
         let mut f = File::create(&path).unwrap();
         assert!(
-            !f.write_all(data.as_bytes()).is_err(),
+            f.write_all(data.as_bytes()).is_ok(),
             "Test setup failed - could not write file"
         );
     }
diff --git a/tests/by-util/test_paste.rs b/tests/by-util/test_paste.rs
index 1afe84be8..09401ec59 100644
--- a/tests/by-util/test_paste.rs
+++ b/tests/by-util/test_paste.rs
@@ -60,6 +60,24 @@ static EXAMPLE_DATA: &[TestData] = &[
         ins: &["1\na\n", "2\nb\n"],
         out: "1 2\na b\n",
     },
+    TestData {
+        name: "multibyte-delim",
+        args: &["-d", "💣"],
+        ins: &["1\na\n", "2\nb\n"],
+        out: "1💣2\na💣b\n",
+    },
+    TestData {
+        name: "multibyte-delim-serial",
+        args: &["-d", "💣", "-s"],
+        ins: &["1\na\n", "2\nb\n"],
+        out: "1💣a\n2💣b\n",
+    },
+    TestData {
+        name: "trailing whitespace",
+        args: &["-d", "|"],
+        ins: &["1 \na \n", "2\t\nb\t\n"],
+        out: "1 |2\t\na |b\t\n",
+    },
 ];
 
 #[test]
diff --git a/tests/by-util/test_pinky.rs b/tests/by-util/test_pinky.rs
index 5394dfde9..c036d449f 100644
--- a/tests/by-util/test_pinky.rs
+++ b/tests/by-util/test_pinky.rs
@@ -24,14 +24,11 @@ fn test_capitalize() {
 fn test_long_format() {
     let login = "root";
     let pw: Passwd = Passwd::locate(login).unwrap();
-    let real_name = pw.user_info().replace("&", &pw.name().capitalize());
+    let real_name = pw.user_info.replace('&', &pw.name.capitalize());
     let ts = TestScenario::new(util_name!());
     ts.ucmd().arg("-l").arg(login).succeeds().stdout_is(format!(
         "Login name: {:<28}In real life:  {}\nDirectory: {:<29}Shell:  {}\n\n",
-        login,
-        real_name,
-        pw.user_dir(),
-        pw.user_shell()
+        login, real_name, pw.user_dir, pw.user_shell
     ));
 
     ts.ucmd()
@@ -47,7 +44,14 @@ fn test_long_format() {
 #[cfg(unix)]
 #[test]
 fn test_long_format_multiple_users() {
-    let args = ["-l", "root", "root", "root"];
+    // multiple instances of one account we know exists,
+    // the account of the test runner,
+    // and an account that (probably) doesn't exist
+    let runner = match std::env::var("USER") {
+        Ok(user) => user,
+        Err(_) => "".to_string(),
+    };
+    let args = ["-l", "root", "root", "root", &runner, "no_such_user"];
     let ts = TestScenario::new(util_name!());
     let expect = unwrap_or_return!(expected_result(&ts, &args));
 
@@ -61,7 +65,7 @@ fn test_long_format_multiple_users() {
 #[test]
 fn test_long_format_wo_user() {
     // "no username specified; at least one must be specified when using -l"
-    new_ucmd!().arg("-l").fails().code_is(1);
+    new_ucmd!().arg("-l").fails();
 }
 
 #[cfg(unix)]
diff --git a/tests/by-util/test_pr.rs b/tests/by-util/test_pr.rs
index 5c16e7acc..2e72aaed7 100644
--- a/tests/by-util/test_pr.rs
+++ b/tests/by-util/test_pr.rs
@@ -448,3 +448,16 @@ fn test_with_join_lines_option() {
             &valid_last_modified_template_vars(start),
         );
 }
+
+#[test]
+fn test_value_for_number_lines() {
+    // *5 is of the form [SEP[NUMBER]] so is accepted and succeeds
+    new_ucmd!().args(&["-n", "*5", "test.log"]).succeeds();
+
+    // a is of the form [SEP[NUMBER]] so is accepted and succeeds
+    new_ucmd!().args(&["-n", "a", "test.log"]).succeeds();
+
+    // foo5.txt is of not the form [SEP[NUMBER]] so is not used as value.
+    // Therefore, pr tries to access the file, which does not exist.
+    new_ucmd!().args(&["-n", "foo5.txt", "test.log"]).fails();
+}
diff --git a/tests/by-util/test_printenv.rs b/tests/by-util/test_printenv.rs
index bc0bc0f3c..e02d93254 100644
--- a/tests/by-util/test_printenv.rs
+++ b/tests/by-util/test_printenv.rs
@@ -26,5 +26,5 @@ fn test_get_var() {
         .succeeds();
 
     assert!(!result.stdout_str().is_empty());
-    assert!(result.stdout_str().trim() == "VALUE");
+    assert_eq!(result.stdout_str().trim(), "VALUE");
 }
diff --git a/tests/by-util/test_printf.rs b/tests/by-util/test_printf.rs
index b5c9dc3ed..d5be4cd17 100644
--- a/tests/by-util/test_printf.rs
+++ b/tests/by-util/test_printf.rs
@@ -228,6 +228,22 @@ fn sub_num_float() {
         .stdout_only("twenty is 20.000000");
 }
 
+#[test]
+fn sub_num_float_e_round() {
+    new_ucmd!()
+        .args(&["%e", "99999999"])
+        .succeeds()
+        .stdout_only("1.000000e+08");
+}
+
+#[test]
+fn sub_num_float_e_no_round() {
+    new_ucmd!()
+        .args(&["%e", "99999994"])
+        .succeeds()
+        .stdout_only("9.999999e+07");
+}
+
 #[test]
 fn sub_num_float_round() {
     new_ucmd!()
@@ -236,6 +252,14 @@ fn sub_num_float_round() {
         .stdout_only("two is 2.000000");
 }
 
+#[test]
+fn sub_num_float_round_nines_dec() {
+    new_ucmd!()
+        .args(&["%f", "0.99999999"])
+        .succeeds()
+        .stdout_only("1.000000");
+}
+
 #[test]
 fn sub_num_sci_lower() {
     new_ucmd!()
@@ -265,7 +289,7 @@ fn sub_num_dec_trunc() {
     new_ucmd!()
         .args(&["pi is ~ %g", "3.1415926535"])
         .succeeds()
-        .stdout_only("pi is ~ 3.141593");
+        .stdout_only("pi is ~ 3.14159");
 }
 
 #[cfg_attr(not(feature = "test_unimplemented"), ignore)]
@@ -429,3 +453,72 @@ fn sub_any_specifiers_after_second_param() {
         .succeeds()
         .stdout_only("3");
 }
+
+#[test]
+fn stop_after_additional_escape() {
+    new_ucmd!()
+        .args(&["A%sC\\cD%sF", "B", "E"]) //spell-checker:disable-line
+        .succeeds()
+        .stdout_only("ABC");
+}
+
+#[test]
+fn sub_float_leading_zeroes() {
+    new_ucmd!()
+        .args(&["%010f", "1"])
+        .succeeds()
+        .stdout_only("001.000000");
+}
+
+#[test]
+fn sub_general_float() {
+    new_ucmd!()
+        .args(&["%g", "1.1"])
+        .succeeds()
+        .stdout_only("1.1");
+}
+
+#[test]
+fn sub_general_truncate_to_integer() {
+    new_ucmd!().args(&["%g", "1.0"]).succeeds().stdout_only("1");
+}
+
+#[test]
+fn sub_general_scientific_notation() {
+    new_ucmd!()
+        .args(&["%g", "1000010"])
+        .succeeds()
+        .stdout_only("1.00001e+06");
+}
+
+#[test]
+fn sub_general_round_scientific_notation() {
+    new_ucmd!()
+        .args(&["%g", "123456789"])
+        .succeeds()
+        .stdout_only("1.23457e+08");
+}
+
+#[test]
+fn sub_general_round_float() {
+    new_ucmd!()
+        .args(&["%g", "12345.6789"])
+        .succeeds()
+        .stdout_only("12345.7");
+}
+
+#[test]
+fn sub_general_round_float_to_integer() {
+    new_ucmd!()
+        .args(&["%g", "123456.7"])
+        .succeeds()
+        .stdout_only("123457");
+}
+
+#[test]
+fn sub_general_round_float_leading_zeroes() {
+    new_ucmd!()
+        .args(&["%g", "1.000009"])
+        .succeeds()
+        .stdout_only("1.00001");
+}
diff --git a/tests/by-util/test_realpath.rs b/tests/by-util/test_realpath.rs
index 72bf5b6ea..e0875cc77 100644
--- a/tests/by-util/test_realpath.rs
+++ b/tests/by-util/test_realpath.rs
@@ -149,8 +149,8 @@ fn test_realpath_dangling() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.symlink_file("nonexistent-file", "link");
     ucmd.arg("link")
-        .succeeds()
-        .stdout_only(at.plus_as_string("nonexistent-file\n"));
+        .fails()
+        .stderr_contains("realpath: link: No such file or directory");
 }
 
 #[test]
@@ -202,3 +202,34 @@ fn test_realpath_missing() {
         .succeeds()
         .stdout_only(expect);
 }
+
+#[test]
+fn test_realpath_when_symlink_is_absolute_and_enoent() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("dir2");
+    at.touch("dir2/bar");
+
+    at.mkdir("dir1");
+    at.symlink_file("dir2/bar", "dir1/foo1");
+    at.symlink_file("/dir2/bar", "dir1/foo2");
+    at.relative_symlink_file("dir2/baz", at.plus("dir1/foo3").to_str().unwrap());
+
+    #[cfg(unix)]
+    ucmd.arg("dir1/foo1")
+        .arg("dir1/foo2")
+        .arg("dir1/foo3")
+        .run()
+        .stdout_contains("/dir2/bar\n")
+        .stdout_contains("/dir2/baz\n")
+        .stderr_is("realpath: dir1/foo2: No such file or directory");
+
+    #[cfg(windows)]
+    ucmd.arg("dir1/foo1")
+        .arg("dir1/foo2")
+        .arg("dir1/foo3")
+        .run()
+        .stdout_contains("\\dir2\\bar\n")
+        .stdout_contains("\\dir2\\baz\n")
+        .stderr_is("realpath: dir1/foo2: No such file or directory");
+}
diff --git a/tests/by-util/test_relpath.rs b/tests/by-util/test_relpath.rs
index 44a685c90..52b829fdf 100644
--- a/tests/by-util/test_relpath.rs
+++ b/tests/by-util/test_relpath.rs
@@ -64,7 +64,7 @@ const TESTS: [TestCase; 10] = [
 #[allow(clippy::needless_lifetimes)]
 fn convert_path<'a>(path: &'a str) -> Cow<'a, str> {
     #[cfg(windows)]
-    return path.replace("/", "\\").into();
+    return path.replace('/', "\\").into();
     #[cfg(not(windows))]
     return path.into();
 }
@@ -74,7 +74,7 @@ fn test_relpath_with_from_no_d() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    for test in TESTS.iter() {
+    for test in &TESTS {
         let from: &str = &convert_path(test.from);
         let to: &str = &convert_path(test.to);
         let expected: &str = &convert_path(test.expected);
@@ -96,7 +96,7 @@ fn test_relpath_with_from_with_d() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    for test in TESTS.iter() {
+    for test in &TESTS {
         let from: &str = &convert_path(test.from);
         let to: &str = &convert_path(test.to);
         let pwd = at.as_string();
@@ -132,7 +132,7 @@ fn test_relpath_no_from_no_d() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    for test in TESTS.iter() {
+    for test in &TESTS {
         let to: &str = &convert_path(test.to);
         at.mkdir_all(to);
 
@@ -150,7 +150,7 @@ fn test_relpath_no_from_with_d() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    for test in TESTS.iter() {
+    for test in &TESTS {
         let to: &str = &convert_path(test.to);
         let pwd = at.as_string();
         at.mkdir_all(to);
diff --git a/tests/by-util/test_rm.rs b/tests/by-util/test_rm.rs
index 32bc43837..1b45175a8 100644
--- a/tests/by-util/test_rm.rs
+++ b/tests/by-util/test_rm.rs
@@ -169,6 +169,29 @@ fn test_rm_recursive() {
     assert!(!at.file_exists(file_b));
 }
 
+#[test]
+fn test_rm_recursive_multiple() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir = "test_rm_recursive_directory";
+    let file_a = "test_rm_recursive_directory/test_rm_recursive_file_a";
+    let file_b = "test_rm_recursive_directory/test_rm_recursive_file_b";
+
+    at.mkdir(dir);
+    at.touch(file_a);
+    at.touch(file_b);
+
+    ucmd.arg("-r")
+        .arg("-r")
+        .arg("-r")
+        .arg(dir)
+        .succeeds()
+        .no_stderr();
+
+    assert!(!at.dir_exists(dir));
+    assert!(!at.file_exists(file_a));
+    assert!(!at.file_exists(file_b));
+}
+
 #[test]
 fn test_rm_directory_without_flag() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -257,7 +280,7 @@ fn test_rm_force_no_operand() {
 fn test_rm_no_operand() {
     let ts = TestScenario::new(util_name!());
     ts.ucmd().fails().stderr_is(&format!(
-        "{0}: missing an argument\n{0}: for help, try '{1} {0} --help'\n",
+        "{0}: missing operand\nTry '{1} {0} --help' for more information.\n",
         ts.util_name,
         ts.bin_path.to_string_lossy()
     ));
@@ -291,3 +314,36 @@ fn test_rm_verbose_slash() {
     assert!(!at.dir_exists(dir));
     assert!(!at.file_exists(file_a));
 }
+
+#[test]
+fn test_rm_silently_accepts_presume_input_tty2() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file_2 = "test_rm_silently_accepts_presume_input_tty2";
+
+    at.touch(file_2);
+
+    ucmd.arg("---presume-input-tty").arg(file_2).succeeds();
+
+    assert!(!at.file_exists(file_2));
+}
+
+#[test]
+fn test_rm_interactive_never() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file_2 = "test_rm_interactive";
+
+    at.touch(file_2);
+    #[cfg(feature = "chmod")]
+    scene.ccmd("chmod").arg("0").arg(file_2).succeeds();
+
+    scene
+        .ucmd()
+        .arg("--interactive=never")
+        .arg(file_2)
+        .succeeds()
+        .stdout_is("");
+
+    assert!(!at.file_exists(file_2));
+}
diff --git a/tests/by-util/test_seq.rs b/tests/by-util/test_seq.rs
index 6ed3cb67d..a18cbc2ad 100644
--- a/tests/by-util/test_seq.rs
+++ b/tests/by-util/test_seq.rs
@@ -1,3 +1,4 @@
+// spell-checker:ignore lmnop xlmnop
 use crate::common::util::*;
 use std::io::Read;
 
@@ -7,26 +8,26 @@ fn test_hex_rejects_sign_after_identifier() {
         .args(&["0x-123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains("invalid hexadecimal argument: '0x-123ABC'")
+        .stderr_contains("invalid floating point argument: '0x-123ABC'")
         .stderr_contains("for more information.");
     new_ucmd!()
         .args(&["0x+123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains("invalid hexadecimal argument: '0x+123ABC'")
+        .stderr_contains("invalid floating point argument: '0x+123ABC'")
         .stderr_contains("for more information.");
     new_ucmd!()
         .args(&["-0x-123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains("invalid hexadecimal argument: '-0x-123ABC'")
-        .stderr_contains("for more information.");
+        .stderr_contains("which wasn't expected, or isn't valid in this context")
+        .stderr_contains("For more information try --help");
     new_ucmd!()
         .args(&["-0x+123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains("invalid hexadecimal argument: '-0x+123ABC'")
-        .stderr_contains("for more information.");
+        .stderr_contains("which wasn't expected, or isn't valid in this context")
+        .stderr_contains("For more information try --help");
 }
 
 #[test]
@@ -60,30 +61,51 @@ fn test_hex_identifier_in_wrong_place() {
         .args(&["1234ABCD0x"])
         .fails()
         .no_stdout()
-        .stderr_contains("invalid hexadecimal argument: '1234ABCD0x'")
+        .stderr_contains("invalid floating point argument: '1234ABCD0x'")
         .stderr_contains("for more information.");
 }
 
 #[test]
 fn test_rejects_nan() {
-    let ts = TestScenario::new(util_name!());
-
-    ts.ucmd().args(&["NaN"]).fails().stderr_only(format!(
-        "{0}: invalid 'not-a-number' argument: 'NaN'\nTry '{1} {0} --help' for more information.",
-        ts.util_name,
-        ts.bin_path.to_string_lossy()
-    ));
+    new_ucmd!()
+        .arg("NaN")
+        .fails()
+        .usage_error("invalid 'not-a-number' argument: 'NaN'");
 }
 
 #[test]
 fn test_rejects_non_floats() {
-    let ts = TestScenario::new(util_name!());
+    new_ucmd!()
+        .arg("foo")
+        .fails()
+        .usage_error("invalid floating point argument: 'foo'");
+}
 
-    ts.ucmd().args(&["foo"]).fails().stderr_only(&format!(
-        "{0}: invalid floating point argument: 'foo'\nTry '{1} {0} --help' for more information.",
-        ts.util_name,
-        ts.bin_path.to_string_lossy()
-    ));
+#[test]
+fn test_accepts_option_argument_directly() {
+    new_ucmd!()
+        .arg("-s,")
+        .arg("2")
+        .succeeds()
+        .stdout_is("1,2\n");
+}
+
+#[test]
+fn test_option_with_detected_negative_argument() {
+    new_ucmd!()
+        .arg("-s,")
+        .args(&["-1", "2"])
+        .succeeds()
+        .stdout_is("-1,0,1,2\n");
+}
+
+#[test]
+fn test_negative_number_as_separator() {
+    new_ucmd!()
+        .arg("-s")
+        .args(&["-1", "2"])
+        .succeeds()
+        .stdout_is("1-12\n");
 }
 
 #[test]
@@ -479,6 +501,72 @@ fn test_width_decimal_scientific_notation_trailing_zeros_increment() {
         .no_stderr();
 }
 
+#[test]
+fn test_width_negative_decimal_notation() {
+    new_ucmd!()
+        .args(&["-w", "-.1", ".1", ".11"])
+        .succeeds()
+        .stdout_is("-0.1\n00.0\n00.1\n")
+        .no_stderr();
+}
+
+#[test]
+fn test_width_negative_scientific_notation() {
+    new_ucmd!()
+        .args(&["-w", "-1e-3", "1"])
+        .succeeds()
+        .stdout_is("-0.001\n00.999\n")
+        .no_stderr();
+    new_ucmd!()
+        .args(&["-w", "-1.e-3", "1"])
+        .succeeds()
+        .stdout_is("-0.001\n00.999\n")
+        .no_stderr();
+    new_ucmd!()
+        .args(&["-w", "-1.0e-4", "1"])
+        .succeeds()
+        .stdout_is("-0.00010\n00.99990\n")
+        .no_stderr();
+    new_ucmd!()
+        .args(&["-w", "-.1e2", "10", "100"])
+        .succeeds()
+        .stdout_is(
+            "-010
+0000
+0010
+0020
+0030
+0040
+0050
+0060
+0070
+0080
+0090
+0100
+",
+        )
+        .no_stderr();
+    new_ucmd!()
+        .args(&["-w", "-0.1e2", "10", "100"])
+        .succeeds()
+        .stdout_is(
+            "-010
+0000
+0010
+0020
+0030
+0040
+0050
+0060
+0070
+0080
+0090
+0100
+",
+        )
+        .no_stderr();
+}
+
 /// Test that trailing zeros in the end argument do not contribute to width.
 #[test]
 fn test_width_decimal_scientific_notation_trailing_zeros_end() {
@@ -521,6 +609,22 @@ fn test_inf() {
     run(&["inf"], b"1\n2\n3\n");
 }
 
+#[test]
+fn test_inf_width() {
+    run(
+        &["-w", "1.000", "inf", "inf"],
+        b"1.000\n  inf\n  inf\n  inf\n",
+    );
+}
+
+#[test]
+fn test_neg_inf_width() {
+    run(
+        &["-w", "1.000", "-inf", "-inf"],
+        b"1.000\n -inf\n -inf\n -inf\n",
+    );
+}
+
 #[test]
 fn test_ignore_leading_whitespace() {
     new_ucmd!()
@@ -538,9 +642,99 @@ fn test_trailing_whitespace_error() {
     new_ucmd!()
         .arg("1 ")
         .fails()
+        .usage_error("invalid floating point argument: '1 '");
+}
+
+#[test]
+fn test_negative_zero_int_start_float_increment() {
+    new_ucmd!()
+        .args(&["-0", "0.1", "0.1"])
+        .succeeds()
+        .stdout_is("-0.0\n0.1\n")
+        .no_stderr();
+}
+
+#[test]
+fn test_float_precision_increment() {
+    new_ucmd!()
+        .args(&["999", "0.1", "1000.1"])
+        .succeeds()
+        .stdout_is(
+            "999.0
+999.1
+999.2
+999.3
+999.4
+999.5
+999.6
+999.7
+999.8
+999.9
+1000.0
+1000.1
+",
+        )
+        .no_stderr();
+}
+
+/// Test for floating point precision issues.
+#[test]
+fn test_negative_increment_decimal() {
+    new_ucmd!()
+        .args(&["0.1", "-0.1", "-0.2"])
+        .succeeds()
+        .stdout_is("0.1\n0.0\n-0.1\n-0.2\n")
+        .no_stderr();
+}
+
+#[test]
+fn test_zero_not_first() {
+    new_ucmd!()
+        .args(&["-w", "-0.1", "0.1", "0.1"])
+        .succeeds()
+        .stdout_is("-0.1\n00.0\n00.1\n")
+        .no_stderr();
+}
+
+#[test]
+fn test_rounding_end() {
+    new_ucmd!()
+        .args(&["1", "-1", "0.1"])
+        .succeeds()
+        .stdout_is("1\n")
+        .no_stderr();
+}
+
+#[test]
+fn test_parse_error_float() {
+    new_ucmd!()
+        .arg("lmnop")
+        .fails()
+        .usage_error("invalid floating point argument: 'lmnop'");
+}
+
+#[test]
+fn test_parse_error_hex() {
+    new_ucmd!()
+        .arg("0xlmnop")
+        .fails()
+        .usage_error("invalid hexadecimal argument: '0xlmnop'");
+}
+
+#[test]
+fn test_format_option() {
+    new_ucmd!()
+        .args(&["-f", "%.2f", "0.0", "0.1", "0.5"])
+        .succeeds()
+        .stdout_only("0.00\n0.10\n0.20\n0.30\n0.40\n0.50\n");
+}
+
+#[test]
+fn test_invalid_zero_increment_value() {
+    new_ucmd!()
+        .args(&["0", "0", "1"])
+        .fails()
         .no_stdout()
-        .stderr_contains("seq: invalid floating point argument: '1 '")
-        // FIXME The second line of the error message is "Try 'seq
-        // --help' for more information."
+        .stderr_contains("invalid Zero increment value: '0'")
         .stderr_contains("for more information.");
 }
diff --git a/tests/by-util/test_shuf.rs b/tests/by-util/test_shuf.rs
index cbc01f8cd..682b0dab6 100644
--- a/tests/by-util/test_shuf.rs
+++ b/tests/by-util/test_shuf.rs
@@ -91,7 +91,7 @@ fn test_head_count() {
         result_seq.iter().all(|x| input_seq.contains(x)),
         "Output includes element not from input: {}",
         result.stdout_str()
-    )
+    );
 }
 
 #[test]
@@ -129,7 +129,7 @@ fn test_repeat() {
             .iter()
             .filter(|x| !input_seq.contains(x))
             .collect::<Vec<&i32>>()
-    )
+    );
 }
 
 #[test]
@@ -154,9 +154,7 @@ fn test_shuf_echo_and_input_range_not_allowed() {
     new_ucmd!()
         .args(&["-e", "0", "-i", "0-2"])
         .fails()
-        .stderr_contains(
-            "The argument '--input-range <LO-HI>' cannot be used with '--echo <ARG>...'",
-        );
+        .stderr_contains("cannot be used with");
 }
 
 #[test]
@@ -164,7 +162,7 @@ fn test_shuf_input_range_and_file_not_allowed() {
     new_ucmd!()
         .args(&["-i", "0-9", "file"])
         .fails()
-        .stderr_contains("The argument '<file>' cannot be used with '--input-range <LO-HI>'");
+        .stderr_contains("cannot be used with");
 }
 
 #[test]
@@ -198,3 +196,19 @@ fn test_shuf_invalid_input_line_count() {
         .fails()
         .stderr_contains("invalid line count: 'a'");
 }
+
+#[test]
+fn test_shuf_multiple_input_line_count() {
+    let result = new_ucmd!()
+        .args(&["-i10-200", "-n", "10", "-n", "5"])
+        .succeeds();
+
+    result.no_stderr();
+
+    let result_count = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .count();
+    assert_eq!(result_count, 5, "Output should have 5 items");
+}
diff --git a/tests/by-util/test_sleep.rs b/tests/by-util/test_sleep.rs
index 94a0a6896..c7c6b3af1 100644
--- a/tests/by-util/test_sleep.rs
+++ b/tests/by-util/test_sleep.rs
@@ -1,7 +1,16 @@
+// spell-checker:ignore dont
 use crate::common::util::*;
 
 use std::time::{Duration, Instant};
 
+#[test]
+fn test_invalid_time_interval() {
+    new_ucmd!()
+        .arg("xyz")
+        .fails()
+        .usage_error("invalid time interval 'xyz'");
+}
+
 #[test]
 fn test_sleep_no_suffix() {
     let millis_100 = Duration::from_millis(100);
@@ -115,3 +124,36 @@ fn test_sleep_sum_duration_many() {
 fn test_sleep_wrong_time() {
     new_ucmd!().args(&["0.1s", "abc"]).fails();
 }
+
+// TODO These tests would obviously block for a very long time. We
+// only want to verify that there is no error here, so we could just
+// figure out a way to terminate the child process after a short
+// period of time.
+
+// #[test]
+#[allow(dead_code)]
+fn test_dont_overflow() {
+    new_ucmd!()
+        .arg("9223372036854775808d")
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+}
+
+// #[test]
+#[allow(dead_code)]
+fn test_sum_overflow() {
+    new_ucmd!()
+        .args(&["100000000000000d", "100000000000000d", "100000000000000d"])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+}
+
+#[test]
+fn test_negative_interval() {
+    new_ucmd!()
+        .args(&["--", "-1"])
+        .fails()
+        .usage_error("invalid time interval '-1'");
+}
diff --git a/tests/by-util/test_sort.rs b/tests/by-util/test_sort.rs
index 2aa26ad24..c33d1a986 100644
--- a/tests/by-util/test_sort.rs
+++ b/tests/by-util/test_sort.rs
@@ -155,7 +155,7 @@ fn test_multiple_decimals_general() {
     test_helper(
         "multiple_decimals_general",
         &["-g", "--general-numeric-sort", "--sort=general-numeric"],
-    )
+    );
 }
 
 #[test]
@@ -163,7 +163,7 @@ fn test_multiple_decimals_numeric() {
     test_helper(
         "multiple_decimals_numeric",
         &["-n", "--numeric-sort", "--sort=numeric"],
-    )
+    );
 }
 
 #[test]
@@ -171,7 +171,7 @@ fn test_numeric_with_trailing_invalid_chars() {
     test_helper(
         "numeric_trailing_chars",
         &["-n", "--numeric-sort", "--sort=numeric"],
-    )
+    );
 }
 
 #[test]
@@ -338,24 +338,20 @@ fn test_dictionary_order() {
 
 #[test]
 fn test_dictionary_order2() {
-    for non_dictionary_order2_param in &["-d"] {
-        new_ucmd!()
-            .pipe_in("a👦�aa	b\naaaa	b") // spell-checker:disable-line
-            .arg(non_dictionary_order2_param) // spell-checker:disable-line
-            .succeeds()
-            .stdout_only("a👦�aa	b\naaaa	b\n"); // spell-checker:disable-line
-    }
+    new_ucmd!()
+        .pipe_in("a👦�aa\tb\naaaa\tb") // spell-checker:disable-line
+        .arg("-d")
+        .succeeds()
+        .stdout_only("a👦�aa\tb\naaaa\tb\n"); // spell-checker:disable-line
 }
 
 #[test]
 fn test_non_printing_chars() {
-    for non_printing_chars_param in &["-i"] {
-        new_ucmd!()
-            .pipe_in("a👦�aa\naaaa") // spell-checker:disable-line
-            .arg(non_printing_chars_param) // spell-checker:disable-line
-            .succeeds()
-            .stdout_only("a👦�aa\naaaa\n"); // spell-checker:disable-line
-    }
+    new_ucmd!()
+        .pipe_in("a👦�aa\naaaa") // spell-checker:disable-line
+        .arg("-i")
+        .succeeds()
+        .stdout_only("a👦�aa\naaaa\n"); // spell-checker:disable-line
 }
 
 #[test]
@@ -486,14 +482,12 @@ fn test_default_unsorted_ints2() {
 
 #[test]
 fn test_numeric_unique_ints2() {
-    for numeric_unique_sort_param in &["-nu"] {
-        let input = "9\n9\n8\n1\n";
-        new_ucmd!()
-            .arg(numeric_unique_sort_param)
-            .pipe_in(input)
-            .succeeds()
-            .stdout_only("1\n8\n9\n");
-    }
+    let input = "9\n9\n8\n1\n";
+    new_ucmd!()
+        .arg("-nu")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("1\n8\n9\n");
 }
 
 #[test]
@@ -588,7 +582,7 @@ fn test_keys_with_options_blanks_start() {
 
 #[test]
 fn test_keys_blanks_with_char_idx() {
-    test_helper("keys_blanks", &["-k 1.2b"])
+    test_helper("keys_blanks", &["-k 1.2b"]);
 }
 
 #[test]
@@ -648,7 +642,7 @@ fn test_keys_negative_size_match() {
 
 #[test]
 fn test_keys_ignore_flag() {
-    test_helper("keys_ignore_flag", &["-k 1n -b"])
+    test_helper("keys_ignore_flag", &["-k 1n -b"]);
 }
 
 #[test]
@@ -918,6 +912,7 @@ fn test_compress_merge() {
 
 #[test]
 fn test_compress_fail() {
+    #[cfg(not(windows))]
     TestScenario::new(util_name!())
         .ucmd_keepenv()
         .args(&[
@@ -930,6 +925,21 @@ fn test_compress_fail() {
         ])
         .fails()
         .stderr_only("sort: couldn't execute compress program: errno 2");
+    // With coverage, it fails with a different error:
+    // "thread 'main' panicked at 'called `Option::unwrap()` on ...
+    // So, don't check the output
+    #[cfg(windows)]
+    TestScenario::new(util_name!())
+        .ucmd_keepenv()
+        .args(&[
+            "ext_sort.txt",
+            "-n",
+            "--compress-program",
+            "nonexistent-program",
+            "-S",
+            "10",
+        ])
+        .fails();
 }
 
 #[test]
@@ -980,7 +990,8 @@ fn test_conflict_check_out() {
             .arg("-o=/dev/null")
             .fails()
             .stderr_contains(
-                "error: The argument '--output <FILENAME>' cannot be used with '--check",
+                // the rest of the message might be subject to change
+                "error: The argument",
             );
     }
 }
@@ -1049,10 +1060,13 @@ fn test_separator_null() {
 #[test]
 fn test_output_is_input() {
     let input = "a\nb\nc\n";
-    let (at, mut cmd) = at_and_ucmd!();
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
     at.touch("file");
     at.append("file", input);
-    cmd.args(&["-m", "-u", "-o", "file", "file", "file", "file"])
+    scene
+        .ucmd_keepenv()
+        .args(&["-m", "-u", "-o", "file", "file", "file", "file"])
         .succeeds();
     assert_eq!(at.read("file"), input);
 }
diff --git a/tests/by-util/test_split.rs b/tests/by-util/test_split.rs
index 229925a1c..87c37787e 100644
--- a/tests/by-util/test_split.rs
+++ b/tests/by-util/test_split.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 xzaaa sixhundredfiftyonebytes ninetyonebytes threebytes asciilowercase fghij klmno pqrst uvwxyz fivelines twohundredfortyonebytes onehundredlines nbbbb
 extern crate rand;
 extern crate regex;
 
@@ -12,16 +12,16 @@ use crate::common::util::*;
 use rand::SeedableRng;
 #[cfg(not(windows))]
 use std::env;
-use std::io::Write;
 use std::path::Path;
 use std::{
     fs::{read_dir, File},
-    io::BufWriter,
+    io::{BufWriter, Read, Write},
 };
 
 fn random_chars(n: usize) -> String {
     thread_rng()
         .sample_iter(&rand::distributions::Alphanumeric)
+        .map(char::from)
         .take(n)
         .collect::<String>()
 }
@@ -32,8 +32,8 @@ struct Glob {
 }
 
 impl Glob {
-    fn new(at: &AtPath, directory: &str, regex: &str) -> Glob {
-        Glob {
+    fn new(at: &AtPath, directory: &str, regex: &str) -> Self {
+        Self {
             directory: AtPath::new(Path::new(&at.plus_as_string(directory))),
             regex: Regex::new(regex).unwrap(),
         }
@@ -83,8 +83,8 @@ impl RandomFile {
     const LINESIZE: usize = 32;
 
     /// `create()` file handle located at `at` / `name`
-    fn new(at: &AtPath, name: &str) -> RandomFile {
-        RandomFile {
+    fn new(at: &AtPath, name: &str) -> Self {
+        Self {
             inner: File::create(&at.plus(name)).unwrap(),
         }
     }
@@ -113,7 +113,7 @@ impl RandomFile {
     fn add_lines(&mut self, lines: usize) {
         let mut n = lines;
         while n > 0 {
-            writeln!(self.inner, "{}", random_chars(RandomFile::LINESIZE)).unwrap();
+            writeln!(self.inner, "{}", random_chars(Self::LINESIZE)).unwrap();
             n -= 1;
         }
     }
@@ -228,6 +228,14 @@ fn test_split_additional_suffix() {
     assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
+#[test]
+fn test_additional_suffix_no_slash() {
+    new_ucmd!()
+        .args(&["--additional-suffix", "a/b"])
+        .fails()
+        .usage_error("invalid suffix 'a/b', contains directory separator");
+}
+
 // note: the test_filter* tests below are unix-only
 // windows support has been waived for now because of the difficulty of getting
 // the `cmd` call right
@@ -329,14 +337,321 @@ fn test_split_invalid_bytes_size() {
     {
         let sizes = ["1000G", "10T"];
         for size in &sizes {
-            new_ucmd!()
-                .args(&["-b", size])
-                .fails()
-                .code_is(1)
-                .stderr_only(format!(
-                    "split: invalid number of bytes: '{}': Value too large for defined data type",
-                    size
-                ));
+            new_ucmd!().args(&["-b", size]).succeeds();
         }
     }
 }
+
+#[test]
+fn test_split_chunks_num_chunks_oversized_32() {
+    #[cfg(target_pointer_width = "32")]
+    {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.touch("file");
+        scene
+            .ucmd()
+            .args(&["--number", "5000000000", "file"])
+            .fails()
+            .code_is(1)
+            .stderr_only("split: Number of chunks too big");
+    }
+}
+
+#[test]
+fn test_split_stdin_num_chunks() {
+    new_ucmd!()
+        .args(&["--number=1"])
+        .fails()
+        .code_is(1)
+        .stderr_only("split: -: cannot determine file size");
+}
+
+fn file_read(at: &AtPath, filename: &str) -> String {
+    let mut s = String::new();
+    at.open(filename).read_to_string(&mut s).unwrap();
+    s
+}
+
+// TODO Use char::from_digit() in Rust v1.51.0 or later.
+fn char_from_digit(n: usize) -> char {
+    (b'a' + n as u8) as char
+}
+
+/// Test for the default suffix length behavior: dynamically increasing size.
+#[test]
+fn test_alphabetic_dynamic_suffix_length() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    // Split into chunks of one byte each.
+    //
+    // The input file has (26^2) - 26 + 1 = 651 bytes. This is just
+    // enough to force `split` to dynamically increase the length of
+    // the filename for the very last chunk.
+    //
+    // We expect the output files to be named
+    //
+    //     xaa, xab, xac, ..., xyx, xyy, xyz, xzaaa
+    //
+    ucmd.args(&["-b", "1", "sixhundredfiftyonebytes.txt"])
+        .succeeds();
+    for i in 0..25 {
+        for j in 0..26 {
+            let filename = format!("x{}{}", char_from_digit(i), char_from_digit(j),);
+            let contents = file_read(&at, &filename);
+            assert_eq!(contents, "a");
+        }
+    }
+    assert_eq!(file_read(&at, "xzaaa"), "a");
+}
+
+/// Test for the default suffix length behavior: dynamically increasing size.
+#[test]
+fn test_numeric_dynamic_suffix_length() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    // Split into chunks of one byte each, use numbers instead of
+    // letters as file suffixes.
+    //
+    // The input file has (10^2) - 10 + 1 = 91 bytes. This is just
+    // enough to force `split` to dynamically increase the length of
+    // the filename for the very last chunk.
+    //
+    //     x00, x01, x02, ..., x87, x88, x89, x9000
+    //
+    ucmd.args(&["-d", "-b", "1", "ninetyonebytes.txt"])
+        .succeeds();
+    for i in 0..90 {
+        let filename = format!("x{:02}", i);
+        let contents = file_read(&at, &filename);
+        assert_eq!(contents, "a");
+    }
+    assert_eq!(file_read(&at, "x9000"), "a");
+}
+
+#[test]
+fn test_hex_dynamic_suffix_length() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    // Split into chunks of one byte each, use hexadecimal digits
+    // instead of letters as file suffixes.
+    //
+    // The input file has (16^2) - 16 + 1 = 241 bytes. This is just
+    // enough to force `split` to dynamically increase the length of
+    // the filename for the very last chunk.
+    //
+    //     x00, x01, x02, ..., xed, xee, xef, xf000
+    //
+    ucmd.args(&["-x", "-b", "1", "twohundredfortyonebytes.txt"])
+        .succeeds();
+    for i in 0..240 {
+        let filename = format!("x{:02x}", i);
+        let contents = file_read(&at, &filename);
+        assert_eq!(contents, "a");
+    }
+    assert_eq!(file_read(&at, "xf000"), "a");
+}
+
+#[test]
+fn test_suffixes_exhausted() {
+    new_ucmd!()
+        .args(&["-b", "1", "-a", "1", "asciilowercase.txt"])
+        .fails()
+        .stderr_only("split: output file suffixes exhausted");
+}
+
+#[test]
+fn test_verbose() {
+    new_ucmd!()
+        .args(&["-b", "5", "--verbose", "asciilowercase.txt"])
+        .succeeds()
+        .stdout_only(
+            "creating file 'xaa'
+creating file 'xab'
+creating file 'xac'
+creating file 'xad'
+creating file 'xae'
+creating file 'xaf'
+",
+        );
+}
+
+#[test]
+fn test_number() {
+    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");
+}
+
+#[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");
+}
+
+#[test]
+fn test_split_default_with_io_blksize() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "split_default_with_io_blksize";
+    RandomFile::new(&at, name).add_lines(2000);
+    ucmd.args(&[name, "---io-blksize", "2M"]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 2);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+#[test]
+fn test_invalid_suffix_length() {
+    new_ucmd!()
+        .args(&["-a", "xyz"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("invalid suffix length: 'xyz'");
+}
+
+#[test]
+fn test_include_newlines() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-l", "2", "fivelines.txt"]).succeeds();
+
+    let mut s = String::new();
+    at.open("xaa").read_to_string(&mut s).unwrap();
+    assert_eq!(s, "1\n2\n");
+
+    let mut s = String::new();
+    at.open("xab").read_to_string(&mut s).unwrap();
+    assert_eq!(s, "3\n4\n");
+
+    let mut s = String::new();
+    at.open("xac").read_to_string(&mut s).unwrap();
+    assert_eq!(s, "5\n");
+}
+
+#[test]
+fn test_allow_empty_files() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n", "4", "threebytes.txt"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("xaa"), "a");
+    assert_eq!(at.read("xab"), "b");
+    assert_eq!(at.read("xac"), "c");
+    assert_eq!(at.read("xad"), "");
+}
+
+#[test]
+fn test_elide_empty_files() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-e", "-n", "4", "threebytes.txt"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("xaa"), "a");
+    assert_eq!(at.read("xab"), "b");
+    assert_eq!(at.read("xac"), "c");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_elide_dev_null() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-e", "-n", "3", "/dev/null"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(!at.plus("xaa").exists());
+    assert!(!at.plus("xab").exists());
+    assert!(!at.plus("xac").exists());
+}
+
+#[test]
+fn test_lines() {
+    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
+    };
+
+    // 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");
+}
+
+#[test]
+fn test_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]
+fn test_line_bytes() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-C", "8", "letters.txt"]).succeeds();
+    assert_eq!(at.read("xaa"), "aaaaaaaa");
+    assert_eq!(at.read("xab"), "a\nbbbb\n");
+    assert_eq!(at.read("xac"), "cccc\ndd\n");
+    assert_eq!(at.read("xad"), "ee\n");
+}
+
+#[test]
+fn test_line_bytes_no_final_newline() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-C", "2"])
+        .pipe_in("1\n2222\n3\n4")
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("xaa"), "1\n");
+    assert_eq!(at.read("xab"), "22");
+    assert_eq!(at.read("xac"), "22");
+    assert_eq!(at.read("xad"), "\n");
+    assert_eq!(at.read("xae"), "3\n");
+    assert_eq!(at.read("xaf"), "4");
+}
+
+#[test]
+fn test_line_bytes_no_empty_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-C", "1"])
+        .pipe_in("1\n2222\n3\n4")
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("xaa"), "1");
+    assert_eq!(at.read("xab"), "\n");
+    assert_eq!(at.read("xac"), "2");
+    assert_eq!(at.read("xad"), "2");
+    assert_eq!(at.read("xae"), "2");
+    assert_eq!(at.read("xaf"), "2");
+    assert_eq!(at.read("xag"), "\n");
+    assert_eq!(at.read("xah"), "3");
+    assert_eq!(at.read("xai"), "\n");
+    assert_eq!(at.read("xaj"), "4");
+    assert!(!at.plus("xak").exists());
+}
diff --git a/tests/by-util/test_stat.rs b/tests/by-util/test_stat.rs
index 9bbb1c1ca..65db4804e 100644
--- a/tests/by-util/test_stat.rs
+++ b/tests/by-util/test_stat.rs
@@ -34,6 +34,14 @@ fn test_group_num() {
     assert_eq!("24", group_num("24"));
     assert_eq!("4", group_num("4"));
     assert_eq!("", group_num(""));
+    assert_eq!("-5", group_num("-5"));
+    assert_eq!("-1,234", group_num("-1234"));
+}
+
+#[test]
+#[should_panic]
+fn test_group_num_panic_if_invalid_numeric_characters() {
+    group_num("³³³³³");
 }
 
 #[cfg(test)]
diff --git a/tests/by-util/test_stdbuf.rs b/tests/by-util/test_stdbuf.rs
index c05b65d70..bc723d8e7 100644
--- a/tests/by-util/test_stdbuf.rs
+++ b/tests/by-util/test_stdbuf.rs
@@ -29,9 +29,9 @@ fn test_stdbuf_no_buffer_option_fails() {
 
     ts.ucmd().args(&["head"]).fails().stderr_is(&format!(
         "error: The following required arguments were not provided:\n    \
-         --error <MODE>\n    \
          --input <MODE>\n    \
-         --output <MODE>\n\n\
+         --output <MODE>\n    \
+         --error <MODE>\n\n\
          USAGE:\n    \
          {1} {0} OPTION... COMMAND\n\n\
          For more information try --help",
@@ -53,16 +53,10 @@ fn test_stdbuf_trailing_var_arg() {
 #[cfg(not(target_os = "windows"))]
 #[test]
 fn test_stdbuf_line_buffering_stdin_fails() {
-    let ts = TestScenario::new(util_name!());
-
-    ts.ucmd()
+    new_ucmd!()
         .args(&["-i", "L", "head"])
         .fails()
-        .stderr_is(&format!(
-            "{0}: line buffering stdin is meaningless\nTry '{1} {0} --help' for more information.",
-            ts.util_name,
-            ts.bin_path.to_string_lossy()
-        ));
+        .usage_error("line buffering stdin is meaningless");
 }
 
 #[cfg(not(target_os = "windows"))]
@@ -81,5 +75,15 @@ fn test_stdbuf_invalid_mode_fails() {
             .fails()
             .code_is(125)
             .stderr_contains("stdbuf: invalid mode '1Y': Value too large for defined data type");
+        #[cfg(target_pointer_width = "32")]
+        {
+            new_ucmd!()
+                .args(&[*option, "5GB", "head"])
+                .fails()
+                .code_is(125)
+                .stderr_contains(
+                    "stdbuf: invalid mode '5GB': Value too large for defined data type",
+                );
+        }
     }
 }
diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs
index fc1df296b..fed77e806 100644
--- a/tests/by-util/test_tail.rs
+++ b/tests/by-util/test_tail.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) abcdefghijklmnopqrstuvwxyz efghijklmnopqrstuvwxyz vwxyz emptyfile logfile
+// spell-checker:ignore (ToDO) abcdefghijklmnopqrstuvwxyz efghijklmnopqrstuvwxyz vwxyz emptyfile logfile bogusfile siette ocho nueve diez
 // spell-checker:ignore (libs) kqueue
 // spell-checker:ignore (jargon) tailable untailable
 
@@ -92,6 +92,34 @@ fn test_follow_single() {
     child.kill().unwrap();
 }
 
+/// Test for following when bytes are written that are not valid UTF-8.
+#[test]
+fn test_follow_non_utf8_bytes() {
+    // Tail the test file and start following it.
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut child = ucmd.arg("-f").arg(FOOBAR_TXT).run_no_wait();
+    let expected = at.read("foobar_single_default.expected");
+    assert_eq!(read_size(&mut child, expected.len()), expected);
+
+    // Now append some bytes that are not valid UTF-8.
+    //
+    // The binary integer "10000000" is *not* a valid UTF-8 encoding
+    // of a character: https://en.wikipedia.org/wiki/UTF-8#Encoding
+    //
+    // We also write the newline character because our implementation
+    // of `tail` is attempting to read a line of input, so the
+    // presence of a newline character will force the `follow()`
+    // function to conclude reading input bytes and start writing them
+    // to output. The newline character is not fundamental to this
+    // test, it is just a requirement of the current implementation.
+    let expected = [0b10000000, b'\n'];
+    at.append_bytes(FOOBAR_TXT, &expected);
+    let actual = read_size_bytes(&mut child, expected.len());
+    assert_eq!(actual, expected.to_vec());
+
+    child.kill().unwrap();
+}
+
 #[test]
 fn test_follow_multiple() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -217,13 +245,13 @@ fn test_single_big_args() {
 
     let mut big_input = at.make_file(FILE);
     for i in 0..LINES {
-        writeln!(&mut big_input, "Line {}", i).expect("Could not write to FILE");
+        writeln!(big_input, "Line {}", i).expect("Could not write to FILE");
     }
     big_input.flush().expect("Could not flush FILE");
 
     let mut big_expected = at.make_file(EXPECTED_FILE);
     for i in (LINES - N_ARG)..LINES {
-        writeln!(&mut big_expected, "Line {}", i).expect("Could not write to EXPECTED_FILE");
+        writeln!(big_expected, "Line {}", i).expect("Could not write to EXPECTED_FILE");
     }
     big_expected.flush().expect("Could not flush EXPECTED_FILE");
 
@@ -266,14 +294,14 @@ fn test_bytes_big() {
     let mut big_input = at.make_file(FILE);
     for i in 0..BYTES {
         let digit = from_digit((i % 10) as u32, 10).unwrap();
-        write!(&mut big_input, "{}", digit).expect("Could not write to FILE");
+        write!(big_input, "{}", digit).expect("Could not write to FILE");
     }
     big_input.flush().expect("Could not flush FILE");
 
     let mut big_expected = at.make_file(EXPECTED_FILE);
     for i in (BYTES - N_ARG)..BYTES {
         let digit = from_digit((i % 10) as u32, 10).unwrap();
-        write!(&mut big_expected, "{}", digit).expect("Could not write to EXPECTED_FILE");
+        write!(big_expected, "{}", digit).expect("Could not write to EXPECTED_FILE");
     }
     big_expected.flush().expect("Could not flush EXPECTED_FILE");
 
@@ -302,13 +330,13 @@ fn test_lines_with_size_suffix() {
 
     let mut big_input = at.make_file(FILE);
     for i in 0..LINES {
-        writeln!(&mut big_input, "Line {}", i).expect("Could not write to FILE");
+        writeln!(big_input, "Line {}", i).expect("Could not write to FILE");
     }
     big_input.flush().expect("Could not flush FILE");
 
     let mut big_expected = at.make_file(EXPECTED_FILE);
     for i in (LINES - N_ARG)..LINES {
-        writeln!(&mut big_expected, "Line {}", i).expect("Could not write to EXPECTED_FILE");
+        writeln!(big_expected, "Line {}", i).expect("Could not write to EXPECTED_FILE");
     }
     big_expected.flush().expect("Could not flush EXPECTED_FILE");
 
@@ -512,6 +540,67 @@ fn test_positive_lines() {
         .stdout_is("c\nd\ne\n");
 }
 
+/// Test for reading all but the first NUM lines of a file: `tail -n +3 infile`.
+#[test]
+fn test_positive_lines_file() {
+    new_ucmd!()
+        .args(&["-n", "+7", "foobar.txt"])
+        .succeeds()
+        .stdout_is(
+            "siette
+ocho
+nueve
+diez
+once
+",
+        );
+}
+
+/// Test for reading all but the first NUM bytes of a file: `tail -c +3 infile`.
+#[test]
+fn test_positive_bytes_file() {
+    new_ucmd!()
+        .args(&["-c", "+42", "foobar.txt"])
+        .succeeds()
+        .stdout_is(
+            "ho
+nueve
+diez
+once
+",
+        );
+}
+
+/// Test for reading all but the first NUM lines: `tail -3`.
+#[test]
+fn test_obsolete_syntax_positive_lines() {
+    new_ucmd!()
+        .args(&["-3"])
+        .pipe_in("a\nb\nc\nd\ne\n")
+        .succeeds()
+        .stdout_is("c\nd\ne\n");
+}
+
+/// Test for reading all but the first NUM lines: `tail -n -10`.
+#[test]
+fn test_small_file() {
+    new_ucmd!()
+        .args(&["-n -10"])
+        .pipe_in("a\nb\nc\nd\ne\n")
+        .succeeds()
+        .stdout_is("a\nb\nc\nd\ne\n");
+}
+
+/// Test for reading all but the first NUM lines: `tail -10`.
+#[test]
+fn test_obsolete_syntax_small_file() {
+    new_ucmd!()
+        .args(&["-10"])
+        .pipe_in("a\nb\nc\nd\ne\n")
+        .succeeds()
+        .stdout_is("a\nb\nc\nd\ne\n");
+}
+
 /// Test for reading all lines, specified by `tail -n +0`.
 #[test]
 fn test_positive_zero_lines() {
@@ -550,12 +639,13 @@ fn test_invalid_num() {
                 .args(&["-c", size])
                 .fails()
                 .code_is(1)
-                .stderr_only(format!(
-                    "tail: invalid number of bytes: '{}': Value too large for defined data type",
-                    size
-                ));
+                .stderr_only("tail: Insufficient addressable memory");
         }
     }
+    new_ucmd!()
+        .args(&["-c", "-³"])
+        .fails()
+        .stderr_is("tail: invalid number of bytes: '³'");
 }
 
 #[test]
@@ -1326,3 +1416,40 @@ fn take_stdout_stderr(p: &mut std::process::Child) -> (String, String) {
     p_stderr.read_to_string(&mut buf_stderr).unwrap();
     (buf_stdout, buf_stderr)
 }
+
+#[test]
+fn test_no_such_file() {
+    new_ucmd!()
+        .arg("bogusfile")
+        .fails()
+        .no_stdout()
+        .stderr_contains("cannot open 'bogusfile' for reading: No such file or directory");
+}
+
+#[test]
+fn test_no_trailing_newline() {
+    new_ucmd!().pipe_in("x").succeeds().stdout_only("x");
+}
+
+#[test]
+fn test_lines_zero_terminated() {
+    new_ucmd!()
+        .args(&["-z", "-n", "2"])
+        .pipe_in("a\0b\0c\0d\0e\0")
+        .succeeds()
+        .stdout_only("d\0e\0");
+    new_ucmd!()
+        .args(&["-z", "-n", "+2"])
+        .pipe_in("a\0b\0c\0d\0e\0")
+        .succeeds()
+        .stdout_only("b\0c\0d\0e\0");
+}
+
+#[test]
+fn test_presume_input_pipe_default() {
+    new_ucmd!()
+        .arg("---presume-input-pipe")
+        .pipe_in_fixture(FOOBAR_TXT)
+        .run()
+        .stdout_is_fixture("foobar_stdin_default.expected");
+}
diff --git a/tests/by-util/test_tee.rs b/tests/by-util/test_tee.rs
index f2587a11f..17e3c05cf 100644
--- a/tests/by-util/test_tee.rs
+++ b/tests/by-util/test_tee.rs
@@ -9,7 +9,7 @@ fn test_tee_processing_multiple_operands() {
     // POSIX says: "Processing of at least 13 file operands shall be supported."
 
     let content = "tee_sample_content";
-    for &n in [1, 2, 12, 13].iter() {
+    for &n in &[1, 2, 12, 13] {
         let files = (1..=n).map(|x| x.to_string()).collect::<Vec<_>>();
         let (at, mut ucmd) = at_and_ucmd!();
 
@@ -18,7 +18,7 @@ fn test_tee_processing_multiple_operands() {
             .succeeds()
             .stdout_is(content);
 
-        for file in files.iter() {
+        for file in &files {
             assert!(at.file_exists(file));
             assert_eq!(at.read(file), content);
         }
@@ -63,9 +63,7 @@ fn test_tee_append() {
 fn test_tee_no_more_writeable_1() {
     // equals to 'tee /dev/full out2 <multi_read' call
     let (at, mut ucmd) = at_and_ucmd!();
-    let content = (1..=10)
-        .map(|x| format!("{}\n", x.to_string()))
-        .collect::<String>();
+    let content = (1..=10).map(|x| format!("{}\n", x)).collect::<String>();
     let file_out = "tee_file_out";
 
     ucmd.arg("/dev/full")
@@ -85,9 +83,7 @@ fn test_tee_no_more_writeable_2() {
     // but currently there is no way to redirect stdout to /dev/full
     // so this test is disabled
     let (_at, mut ucmd) = at_and_ucmd!();
-    let _content = (1..=10)
-        .map(|x| format!("{}\n", x.to_string()))
-        .collect::<String>();
+    let _content = (1..=10).map(|x| format!("{}\n", x)).collect::<String>();
     let file_out_a = "tee_file_out_a";
     let file_out_b = "tee_file_out_b";
 
diff --git a/tests/by-util/test_test.rs b/tests/by-util/test_test.rs
index db74265a4..8500d63ed 100644
--- a/tests/by-util/test_test.rs
+++ b/tests/by-util/test_test.rs
@@ -440,7 +440,27 @@ fn test_file_is_not_writable() {
 
 #[test]
 fn test_file_is_not_executable() {
-    new_ucmd!().args(&["!", "-x", "regular_file"]).succeeds();
+    #[cfg(unix)]
+    let (at, mut ucmd) = at_and_ucmd!();
+    #[cfg(not(unix))]
+    let (_, mut ucmd) = at_and_ucmd!();
+
+    // WSL creates executable files by default, so if we are on unix, make sure
+    // to set make it non-executable.
+    // Files on other targets are non-executable by default.
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let metadata = std::fs::metadata(at.plus("regular_file")).unwrap();
+        let mut permissions = metadata.permissions();
+
+        // The conversion is useless on some platforms and casts from u16 to
+        // u32 on others
+        #[allow(clippy::useless_conversion)]
+        permissions.set_mode(permissions.mode() & !u32::from(libc::S_IXUSR));
+        std::fs::set_permissions(at.plus("regular_file"), permissions).unwrap();
+    }
+    ucmd.args(&["!", "-x", "regular_file"]).succeeds();
 }
 
 #[test]
diff --git a/tests/by-util/test_timeout.rs b/tests/by-util/test_timeout.rs
index 9be29065a..fef5fd4ae 100644
--- a/tests/by-util/test_timeout.rs
+++ b/tests/by-util/test_timeout.rs
@@ -1,3 +1,4 @@
+// spell-checker:ignore dont
 use crate::common::util::*;
 
 // FIXME: this depends on the system having true and false in PATH
@@ -10,6 +11,24 @@ fn test_subcommand_return_code() {
     new_ucmd!().arg("1").arg("false").run().status_code(1);
 }
 
+#[test]
+fn test_invalid_time_interval() {
+    new_ucmd!()
+        .args(&["xyz", "sleep", "0"])
+        .fails()
+        .code_is(125)
+        .usage_error("invalid time interval 'xyz'");
+}
+
+#[test]
+fn test_invalid_kill_after() {
+    new_ucmd!()
+        .args(&["-k", "xyz", "1", "sleep", "0"])
+        .fails()
+        .code_is(125)
+        .usage_error("invalid time interval 'xyz'");
+}
+
 #[test]
 fn test_command_with_args() {
     new_ucmd!()
@@ -45,3 +64,64 @@ fn test_zero_timeout() {
         .no_stderr()
         .no_stdout();
 }
+
+#[test]
+fn test_command_empty_args() {
+    new_ucmd!()
+        .args(&["", ""])
+        .fails()
+        .stderr_contains("timeout: empty string");
+}
+
+#[test]
+fn test_preserve_status() {
+    new_ucmd!()
+        .args(&["--preserve-status", ".1", "sleep", "10"])
+        .fails()
+        // 128 + SIGTERM = 128 + 15
+        .code_is(128 + 15)
+        .no_stderr()
+        .no_stdout();
+}
+
+#[test]
+fn test_dont_overflow() {
+    new_ucmd!()
+        .args(&["9223372036854775808d", "sleep", "0"])
+        .succeeds()
+        .code_is(0)
+        .no_stderr()
+        .no_stdout();
+    new_ucmd!()
+        .args(&["-k", "9223372036854775808d", "10", "sleep", "0"])
+        .succeeds()
+        .code_is(0)
+        .no_stderr()
+        .no_stdout();
+}
+
+#[test]
+fn test_negative_interval() {
+    new_ucmd!()
+        .args(&["--", "-1", "sleep", "0"])
+        .fails()
+        .usage_error("invalid time interval '-1'");
+}
+
+#[test]
+fn test_invalid_signal() {
+    new_ucmd!()
+        .args(&["-s", "invalid", "1", "sleep", "0"])
+        .fails()
+        .usage_error("'invalid': invalid signal");
+}
+
+/// Test that the long form of the `--kill-after` argument is recognized.
+#[test]
+fn test_kill_after_long() {
+    new_ucmd!()
+        .args(&["--kill-after=1", "1", "sleep", "0"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+}
diff --git a/tests/by-util/test_touch.rs b/tests/by-util/test_touch.rs
index 983d14fe2..d7a0df129 100644
--- a/tests/by-util/test_touch.rs
+++ b/tests/by-util/test_touch.rs
@@ -27,7 +27,7 @@ fn get_symlink_times(at: &AtPath, path: &str) -> (FileTime, FileTime) {
 }
 
 fn set_file_times(at: &AtPath, path: &str, atime: FileTime, mtime: FileTime) {
-    filetime::set_file_times(&at.plus_as_string(path), atime, mtime).unwrap()
+    filetime::set_file_times(&at.plus_as_string(path), atime, mtime).unwrap();
 }
 
 // Adjusts for local timezone
@@ -427,7 +427,7 @@ fn test_touch_mtime_dst_succeeds() {
 
     let target_time = str_to_filetime("%Y%m%d%H%M", "202103140300");
     let (_, mtime) = get_file_times(&at, file);
-    assert!(target_time == mtime);
+    assert_eq!(target_time, mtime);
 }
 
 // is_dst_switch_hour returns true if timespec ts is just before the switch
@@ -510,6 +510,27 @@ fn test_touch_no_such_file_error_msg() {
     ));
 }
 
+#[test]
+fn test_touch_changes_time_of_file_in_stdout() {
+    // command like: `touch - 1< ./c`
+    // should change the timestamp of c
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_touch_changes_time_of_file_in_stdout";
+
+    at.touch(file);
+    assert!(at.file_exists(file));
+    let (_, mtime) = get_file_times(&at, file);
+
+    ucmd.args(&["-"])
+        .set_stdout(at.make_file(file))
+        .succeeds()
+        .no_stderr();
+
+    let (_, mtime_after) = get_file_times(&at, file);
+    assert!(mtime_after != mtime);
+}
+
 #[test]
 #[cfg(unix)]
 fn test_touch_permission_denied_error_msg() {
@@ -530,3 +551,25 @@ fn test_touch_permission_denied_error_msg() {
         &full_path
     ));
 }
+
+#[test]
+fn test_touch_no_args() {
+    let mut ucmd = new_ucmd!();
+    ucmd.fails().stderr_only(
+        r##"touch: missing file operand
+Try 'touch --help' for more information."##,
+    );
+}
+
+#[test]
+fn test_no_dereference_no_file() {
+    new_ucmd!()
+        .args(&["-h", "not-a-file"])
+        .fails()
+        .stderr_contains("setting times of 'not-a-file': No such file or directory");
+    new_ucmd!()
+        .args(&["-h", "not-a-file-1", "not-a-file-2"])
+        .fails()
+        .stderr_contains("setting times of 'not-a-file-1': No such file or directory")
+        .stderr_contains("setting times of 'not-a-file-2': No such file or directory");
+}
diff --git a/tests/by-util/test_tr.rs b/tests/by-util/test_tr.rs
index bd022b1c2..bf550a109 100644
--- a/tests/by-util/test_tr.rs
+++ b/tests/by-util/test_tr.rs
@@ -1,3 +1,4 @@
+// spell-checker:ignore aabbaa aabbcc aabc abbb abcc abcdefabcdef abcdefghijk abcdefghijklmn abcdefghijklmnop ABCDEFGHIJKLMNOPQRS abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCDEFZZ abcxyz ABCXYZ abcxyzabcxyz ABCXYZABCXYZ acbdef alnum amzamz AMZXAMZ bbbd cclass cefgm cntrl compl dabcdef dncase Gzabcdefg PQRST upcase wxyzz xdigit xycde xyyye xyyz xyzzzzxyzzzz ZABCDEF Zamz Cdefghijkl Cdefghijklmn
 use crate::common::util::*;
 
 #[test]
@@ -98,12 +99,11 @@ fn test_complement4() {
 }
 
 #[test]
-#[ignore = "fixme: GNU tr returns '0a1b2c3' instead of '0~1~2~3', see #2158"]
 fn test_complement5() {
-    // $ echo '0x1y2z3' | tr -c '\0-@' '*-~'
+    // $ echo -n '0x1y2z3' | tr -c '\0-@' '*-~'
     // 0a1b2c3
     new_ucmd!()
-        .args(&["-c", "\\0-@", "*-~"])
+        .args(&["-c", r"\0-@", "*-~"])
         .pipe_in("0x1y2z3")
         .run()
         .stdout_is("0a1b2c3");
@@ -192,6 +192,7 @@ fn test_set1_shorter_than_set2() {
 
 #[test]
 fn test_truncate() {
+    // echo -n "abcde" | tr -t "abc" "xy"
     new_ucmd!()
         .args(&["-t", "abc", "xy"])
         .pipe_in("abcde")
@@ -286,11 +287,835 @@ fn test_interpret_backslash_at_eol_literally() {
 }
 
 #[test]
-// FixME: panicked at 'failed to write to stdin of child: Broken pipe (os error 32)
-#[cfg(not(target_os = "freebsd"))]
 fn test_more_than_2_sets() {
-    new_ucmd!()
-        .args(&["'abcdefgh'", "'a", "'b'"])
-        .pipe_in("hello world")
-        .fails();
+    new_ucmd!().args(&["'abcdef'", "'a'", "'b'"]).fails();
+}
+
+#[test]
+fn basic_translation_works() {
+    // echo -n "abcdefabcdef" | tr "dabcdef"  "xyz"
+    new_ucmd!()
+        .args(&["abcdef", "xyz"])
+        .pipe_in("abcdefabcdef")
+        .succeeds()
+        .stdout_is("xyzzzzxyzzzz");
+}
+
+#[test]
+fn alnum_overrides_translation_to_fallback_1() {
+    // echo -n "abcdefghijklmnopqrstuvwxyz" | tr "abc[:alpha:]" "xyz"
+    new_ucmd!()
+        .args(&["abc[:alpha:]", "xyz"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is("zzzzzzzzzzzzzzzzzzzzzzzzzz");
+}
+
+#[test]
+fn alnum_overrides_translation_to_fallback_2() {
+    // echo -n "abcdefghijklmnopqrstuvwxyz" | tr "[:alpha:]abc" "xyz"
+    new_ucmd!()
+        .args(&["[:alpha:]abc", "xyz"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is("zzzzzzzzzzzzzzzzzzzzzzzzzz");
+}
+
+#[test]
+fn overrides_translation_pair_if_repeats() {
+    // echo -n 'aaa' | tr "aaa" "xyz"
+    new_ucmd!()
+        .args(&["aaa", "xyz"])
+        .pipe_in("aaa")
+        .succeeds()
+        .stdout_is("zzz");
+}
+
+#[test]
+fn uppercase_conversion_works_1() {
+    // echo -n 'abcdefghijklmnopqrstuvwxyz' | tr "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    new_ucmd!()
+        .args(&["abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+}
+
+#[test]
+fn uppercase_conversion_works_2() {
+    // echo -n 'abcdefghijklmnopqrstuvwxyz' | tr "a-z" "A-Z"
+    new_ucmd!()
+        .args(&["a-z", "A-Z"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+}
+
+#[test]
+fn uppercase_conversion_works_3() {
+    // echo -n 'abcdefghijklmnopqrstuvwxyz' | tr "[:lower:]" "[:upper:]"
+    new_ucmd!()
+        .args(&["[:lower:]", "[:upper:]"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+}
+
+#[test]
+fn translate_complement_set_in_order() {
+    // echo -n '01234' | tr -c '@-~' ' -^'
+    new_ucmd!()
+        .args(&["-c", "@-~", " -^"])
+        .pipe_in("01234")
+        .succeeds()
+        .stdout_is("PQRST");
+}
+
+#[test]
+fn alpha_expands_uppercase_lowercase() {
+    // echo -n "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" | tr "[:alpha:]" " -_"
+    new_ucmd!()
+        .args(&["[:alpha:]", " -_"])
+        .pipe_in("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is(r##" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS"##);
+}
+
+#[test]
+fn alnum_expands_number_uppercase_lowercase() {
+    // echo -n "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" | tr "[:alnum:]" " -_"
+    new_ucmd!()
+        .args(&["[:alnum:]", " -_"])
+        .pipe_in("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is(r##" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]"##);
+}
+
+#[test]
+fn check_against_gnu_tr_tests() {
+    // ['1', qw(abcd '[]*]'),   {IN=>'abcd'}, {OUT=>']]]]'}],
+    new_ucmd!()
+        .args(&["abcd", "[]*]"])
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_is("]]]]");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_2() {
+    // ['2', qw(abc '[%*]xyz'), {IN=>'abc'}, {OUT=>'xyz'}],
+    new_ucmd!()
+        .args(&["abc", "[%*]xyz"])
+        .pipe_in("abc")
+        .succeeds()
+        .stdout_is("xyz");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_3() {
+    // ['3', qw('' '[.*]'),     {IN=>'abc'}, {OUT=>'abc'}],
+    new_ucmd!()
+        .args(&["", "[.*]"])
+        .pipe_in("abc")
+        .succeeds()
+        .stdout_is("abc");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_4() {
+    // # Test --truncate-set1 behavior when string1 is longer than string2
+    // ['4', qw(-t abcd xy), {IN=>'abcde'}, {OUT=>'xycde'}],
+    new_ucmd!()
+        .args(&["-t", "abcd", "xy"])
+        .pipe_in("abcde")
+        .succeeds()
+        .stdout_is("xycde");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_5() {
+    // # Test bsd behavior (the default) when string1 is longer than string2
+    // ['5', qw(abcd xy), {IN=>'abcde'}, {OUT=>'xyyye'}],
+    new_ucmd!()
+        .args(&["abcd", "xy"])
+        .pipe_in("abcde")
+        .succeeds()
+        .stdout_is("xyyye");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_6() {
+    // # Do it the posix way
+    // ['6', qw(abcd 'x[y*]'), {IN=>'abcde'}, {OUT=>'xyyye'}],
+    new_ucmd!()
+        .args(&["abcd", "x[y*]"])
+        .pipe_in("abcde")
+        .succeeds()
+        .stdout_is("xyyye");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_7() {
+    // ['7', qw(-s a-p '%[.*]$'), {IN=>'abcdefghijklmnop'}, {OUT=>'%.$'}],
+    new_ucmd!()
+        .args(&["-s", "a-p", "%[.*]$"])
+        .pipe_in("abcdefghijklmnop")
+        .succeeds()
+        .stdout_is("%.$");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_8() {
+    // ['8', qw(-s a-p '[.*]$'), {IN=>'abcdefghijklmnop'}, {OUT=>'.$'}],
+    new_ucmd!()
+        .args(&["-s", "a-p", "[.*]$"])
+        .pipe_in("abcdefghijklmnop")
+        .succeeds()
+        .stdout_is(".$");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_9() {
+    // ['9', qw(-s a-p '%[.*]'), {IN=>'abcdefghijklmnop'}, {OUT=>'%.'}],
+    new_ucmd!()
+        .args(&["-s", "a-p", "%[.*]"])
+        .pipe_in("abcdefghijklmnop")
+        .succeeds()
+        .stdout_is("%.");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_a() {
+    // ['a', qw(-s '[a-z]'), {IN=>'aabbcc'}, {OUT=>'abc'}],
+    new_ucmd!()
+        .args(&["-s", "[a-z]"])
+        .pipe_in("aabbcc")
+        .succeeds()
+        .stdout_is("abc");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_b() {
+    // ['b', qw(-s '[a-c]'), {IN=>'aabbcc'}, {OUT=>'abc'}],
+    new_ucmd!()
+        .args(&["-s", "[a-c]"])
+        .pipe_in("aabbcc")
+        .succeeds()
+        .stdout_is("abc");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_c() {
+    // ['c', qw(-s '[a-b]'), {IN=>'aabbcc'}, {OUT=>'abcc'}],
+    new_ucmd!()
+        .args(&["-s", "[a-b]"])
+        .pipe_in("aabbcc")
+        .succeeds()
+        .stdout_is("abcc");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_d() {
+    // ['d', qw(-s '[b-c]'), {IN=>'aabbcc'}, {OUT=>'aabc'}],
+    new_ucmd!()
+        .args(&["-s", "[b-c]"])
+        .pipe_in("aabbcc")
+        .succeeds()
+        .stdout_is("aabc");
+}
+
+#[test]
+#[ignore = "I cannot tell if this means that tr preserve the octal representation?"]
+fn check_against_gnu_tr_tests_e() {
+    // ['e', qw(-s '[\0-\5]'), {IN=>"\0\0a\1\1b\2\2\2c\3\3\3d\4\4\4\4e\5\5"}, {OUT=>"\0a\1b\2c\3d\4e\5"}],
+    new_ucmd!()
+        .args(&["-s", r"[\0-\5]"])
+        .pipe_in(
+            "\u{0}\u{0}a\u{1}\u{1}b\u{2}\u{2}\u{2}c\u{3}\u{3}\u{3}d\u{4}\u{4}\u{4}\u{4}e\u{5}\u{5}",
+        )
+        .succeeds()
+        .stdout_is("\u{0}a\u{1}b\u{2}c\u{3}d\u{4}e\u{5}");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_f() {
+    // # tests of delete
+    // ['f', qw(-d '[=[=]'), {IN=>'[[[[[[[]]]]]]]]'}, {OUT=>']]]]]]]]'}],
+    new_ucmd!()
+        .args(&["-d", "[=[=]"])
+        .pipe_in("[[[[[[[]]]]]]]]")
+        .succeeds()
+        .stdout_is("]]]]]]]]");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_g() {
+    // ['g', qw(-d '[=]=]'), {IN=>'[[[[[[[]]]]]]]]'}, {OUT=>'[[[[[[['}],
+    new_ucmd!()
+        .args(&["-d", "[=]=]"])
+        .pipe_in("[[[[[[[]]]]]]]]")
+        .succeeds()
+        .stdout_is("[[[[[[[");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_h() {
+    // ['h', qw(-d '[:xdigit:]'), {IN=>'0123456789acbdefABCDEF'}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-d", "[:xdigit:]"])
+        .pipe_in("0123456789acbdefABCDEF")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_i() {
+    // ['i', qw(-d '[:xdigit:]'), {IN=>'w0x1y2z3456789acbdefABCDEFz'}, {OUT=>'wxyzz'}],
+    new_ucmd!()
+        .args(&["-d", "[:xdigit:]"])
+        .pipe_in("w0x1y2z3456789acbdefABCDEFz")
+        .succeeds()
+        .stdout_is("wxyzz");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_j() {
+    // ['j', qw(-d '[:digit:]'), {IN=>'0123456789'}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-d", "[:digit:]"])
+        .pipe_in("0123456789")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_k() {
+    // ['k', qw(-d '[:digit:]'), {IN=>'a0b1c2d3e4f5g6h7i8j9k'}, {OUT=>'abcdefghijk'}],
+    new_ucmd!()
+        .args(&["-d", "[:digit:]"])
+        .pipe_in("a0b1c2d3e4f5g6h7i8j9k")
+        .succeeds()
+        .stdout_is("abcdefghijk");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_l() {
+    // ['l', qw(-d '[:lower:]'), {IN=>'abcdefghijklmnopqrstuvwxyz'}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-d", "[:lower:]"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyz")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_m() {
+    // ['m', qw(-d '[:upper:]'), {IN=>'ABCDEFGHIJKLMNOPQRSTUVWXYZ'}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-d", "[:upper:]"])
+        .pipe_in("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_n() {
+    // ['n', qw(-d '[:lower:][:upper:]'), {IN=>'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-d", "[:lower:][:upper:]"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_o() {
+    // ['o', qw(-d '[:alpha:]'), {IN=>'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-d", "[:alpha:]"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_p() {
+    // ['p', qw(-d '[:alnum:]'), {IN=>'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-d", "[:alnum:]"])
+        .pipe_in("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_q() {
+    // ['q', qw(-d '[:alnum:]'), {IN=>'.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.'}, {OUT=>'..'}],
+    new_ucmd!()
+        .args(&["-d", "[:alnum:]"])
+        .pipe_in(".abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.")
+        .succeeds()
+        .stdout_is("..");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_r() {
+    // ['r', qw(-ds '[:alnum:]' .),
+    //  {IN=>'.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.'},
+    //  {OUT=>'.'}],
+    new_ucmd!()
+        .args(&["-ds", "[:alnum:]", "."])
+        .pipe_in(".abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.")
+        .succeeds()
+        .stdout_is(".");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_s() {
+    // # The classic example, with string2 BSD-style
+    // ['s', qw(-cs '[:alnum:]' '\n'),
+    //  {IN=>'The big black fox jumped over the fence.'},
+    //  {OUT=>"The\nbig\nblack\nfox\njumped\nover\nthe\nfence\n"}],
+    new_ucmd!()
+        .args(&["-cs", "[:alnum:]", "\n"])
+        .pipe_in("The big black fox jumped over the fence.")
+        .succeeds()
+        .stdout_is("The\nbig\nblack\nfox\njumped\nover\nthe\nfence\n");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_t() {
+    // # The classic example, POSIX-style
+    // ['t', qw(-cs '[:alnum:]' '[\n*]'),
+    //  {IN=>'The big black fox jumped over the fence.'},
+    //  {OUT=>"The\nbig\nblack\nfox\njumped\nover\nthe\nfence\n"}],
+    new_ucmd!()
+        .args(&["-cs", "[:alnum:]", "[\n*]"])
+        .pipe_in("The big black fox jumped over the fence.")
+        .succeeds()
+        .stdout_is("The\nbig\nblack\nfox\njumped\nover\nthe\nfence\n");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_u() {
+    // ['u', qw(-ds b a), {IN=>'aabbaa'}, {OUT=>'a'}],
+    new_ucmd!()
+        .args(&["-ds", "b", "a"])
+        .pipe_in("aabbaa")
+        .succeeds()
+        .stdout_is("a");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_v() {
+    // ['v', qw(-ds '[:xdigit:]' Z), {IN=>'ZZ0123456789acbdefABCDEFZZ'}, {OUT=>'Z'}],
+    new_ucmd!()
+        .args(&["-ds", "[:xdigit:]", "Z"])
+        .pipe_in("ZZ0123456789acbdefABCDEFZZ")
+        .succeeds()
+        .stdout_is("Z");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_w() {
+    // # Try some data with 8th bit set in case something is mistakenly
+    // # sign-extended.
+    // ['w', qw(-ds '\350' '\345'),
+    //  {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}")
+        .succeeds()
+        .stdout_is("\u{300}\u{301}\u{377}\u{345}");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_x() {
+    // ['x', qw(-s abcdefghijklmn '[:*016]'),
+    //  {IN=>'abcdefghijklmnop'}, {OUT=>':op'}],
+    new_ucmd!()
+        .args(&["-s", "abcdefghijklmn", "[:*016]"])
+        .pipe_in("abcdefghijklmnop")
+        .succeeds()
+        .stdout_is(":op");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_y() {
+    // ['y', qw(-d a-z), {IN=>'abc $code'}, {OUT=>' $'}],
+    new_ucmd!()
+        .args(&["-d", "a-z"])
+        .pipe_in("abc $code")
+        .succeeds()
+        .stdout_is(" $");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_z() {
+    // ['z', qw(-ds a-z '$.'), {IN=>'a.b.c $$$$code\\'}, {OUT=>'. $\\'}],
+    new_ucmd!()
+        .args(&["-ds", "a-z", "$."])
+        .pipe_in("a.b.c $$$$code\\")
+        .succeeds()
+        .stdout_is(". $\\");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_range_a_a() {
+    // # Make sure that a-a is accepted.
+    // ['range-a-a', qw(a-a z), {IN=>'abc'}, {OUT=>'zbc'}],
+    new_ucmd!()
+        .args(&["a-a", "z"])
+        .pipe_in("abc")
+        .succeeds()
+        .stdout_is("zbc");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_null() {
+    // ['null', qw(a ''), {IN=>''}, {OUT=>''}, {EXIT=>1},
+    //  {ERR=>"$prog: when not truncating set1, string2 must be non-empty\n"}],
+    new_ucmd!()
+        .args(&["a", ""])
+        .pipe_in("")
+        .fails()
+        .stderr_is("tr: when not truncating set1, string2 must be non-empty\n");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_upcase() {
+    // ['upcase', qw('[:lower:]' '[:upper:]'),
+    //  {IN=>'abcxyzABCXYZ'},
+    //  {OUT=>'ABCXYZABCXYZ'}],
+    new_ucmd!()
+        .args(&["[:lower:]", "[:upper:]"])
+        .pipe_in("abcxyzABCXYZ")
+        .succeeds()
+        .stdout_is("ABCXYZABCXYZ");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_dncase() {
+    // ['dncase', qw('[:upper:]' '[:lower:]'),
+    //  {IN=>'abcxyzABCXYZ'},
+    //  {OUT=>'abcxyzabcxyz'}],
+    new_ucmd!()
+        .args(&["[:upper:]", "[:lower:]"])
+        .pipe_in("abcxyzABCXYZ")
+        .succeeds()
+        .stdout_is("abcxyzabcxyz");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_rep_cclass() {
+    // ['rep-cclass', qw('a[=*2][=c=]' xyyz), {IN=>'a=c'}, {OUT=>'xyz'}],
+    new_ucmd!()
+        .args(&["a[=*2][=c=]", "xyyz"])
+        .pipe_in("a=c")
+        .succeeds()
+        .stdout_is("xyz");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_rep_1() {
+    // ['rep-1', qw('[:*3][:digit:]' a-m), {IN=>':1239'}, {OUT=>'cefgm'}],
+    new_ucmd!()
+        .args(&["[:*3][:digit:]", "a-m"])
+        .pipe_in(":1239")
+        .succeeds()
+        .stdout_is("cefgm");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_rep_2() {
+    // ['rep-2', qw('a[b*512]c' '1[x*]2'), {IN=>'abc'}, {OUT=>'1x2'}],
+    new_ucmd!()
+        .args(&["a[b*512]c", "1[x*]2"])
+        .pipe_in("abc")
+        .succeeds()
+        .stdout_is("1x2");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_rep_3() {
+    // ['rep-3', qw('a[b*513]c' '1[x*]2'), {IN=>'abc'}, {OUT=>'1x2'}],
+    new_ucmd!()
+        .args(&["a[b*513]c", "1[x*]2"])
+        .pipe_in("abc")
+        .succeeds()
+        .stdout_is("1x2");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_o_rep_1() {
+    // # Another couple octal repeat count tests.
+    // ['o-rep-1', qw('[b*08]' '[x*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
+    //  {ERR=>"$prog: invalid repeat count '08' in [c*n] construct\n"}],
+    new_ucmd!()
+        .args(&["[b*08]", "[x*]"])
+        .pipe_in("")
+        .fails()
+        .stderr_is("tr: invalid repeat count '08' in [c*n] construct\n");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_o_rep_2() {
+    // ['o-rep-2', qw('[b*010]cd' '[a*7]BC[x*]'), {IN=>'bcd'}, {OUT=>'BCx'}],
+    new_ucmd!()
+        .args(&["[b*010]cd", "[a*7]BC[x*]"])
+        .pipe_in("bcd")
+        .succeeds()
+        .stdout_is("BCx");
+}
+
+#[test]
+fn octal_repeat_count_test() {
+    //below will result in 8'x' and 4'y' as octal 010 = decimal 8
+    new_ucmd!()
+        .args(&["ABCdefghijkl", "[x*010]Y"])
+        .pipe_in("ABCdefghijklmn12")
+        .succeeds()
+        .stdout_is("xxxxxxxxYYYYmn12");
+}
+
+#[test]
+fn non_octal_repeat_count_test() {
+    //below will result in 10'x' and 2'y' as the 10 does not have 0 prefix
+    new_ucmd!()
+        .args(&["ABCdefghijkl", "[x*10]Y"])
+        .pipe_in("ABCdefghijklmn12")
+        .succeeds()
+        .stdout_is("xxxxxxxxxxYYmn12");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_esc() {
+    // ['esc', qw('a\-z' A-Z), {IN=>'abc-z'}, {OUT=>'AbcBC'}],
+    new_ucmd!()
+        .args(&[r"a\-z", "A-Z"])
+        .pipe_in("abc-z")
+        .succeeds()
+        .stdout_is("AbcBC");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_bs_055() {
+    // ['bs-055', qw('a\055b' def), {IN=>"a\055b"}, {OUT=>'def'}],
+    new_ucmd!()
+        .args(&["a\u{055}b", "def"])
+        .pipe_in("a\u{055}b")
+        .succeeds()
+        .stdout_is("def");
+}
+
+#[test]
+#[ignore = "Failing in Windows because it will not separate '\' and 'x' as separate arguments"]
+fn check_against_gnu_tr_tests_bs_at_end() {
+    // ['bs-at-end', qw('\\' x), {IN=>"\\"}, {OUT=>'x'},
+    //  {ERR=>"$prog: warning: an unescaped backslash at end of "
+    //   . "string is not portable\n"}],
+    new_ucmd!()
+        .args(&[r"\", "x"])
+        .pipe_in(r"\")
+        .succeeds()
+        .stdout_is("x")
+        .stderr_is("tr: warning: an unescaped backslash at end of string is not portable");
+}
+
+#[test]
+#[ignore = "not sure why GNU bails here. `[Y*]` should be able to generate all the mapping"]
+fn check_against_gnu_tr_tests_ross_0a() {
+    // # From Ross
+    // ['ross-0a', qw(-cs '[:upper:]' 'X[Y*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
+    //  {ERR=>$map_all_to_1}],
+    new_ucmd!()
+        .args(&["-cs", "[:upper:]", "X[Y*]"])
+        .pipe_in("")
+        .fails()
+        .stderr_is("tr: when translating with complemented character classes,\nstring2 must map all characters in the domain to one");
+}
+
+#[test]
+#[ignore = "not sure why GNU bails here. `[Y*]` should be able to generate all the mapping"]
+fn check_against_gnu_tr_tests_ross_0b() {
+    // ['ross-0b', qw(-cs '[:cntrl:]' 'X[Y*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
+    //  {ERR=>$map_all_to_1}],
+    new_ucmd!()
+        .args(&["-cs", "[:cntrl:]", "X[Y*]"])
+        .pipe_in("")
+        .fails()
+        .stderr_is("tr: when translating with complemented character classes,\nstring2 must map all characters in the domain to one");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_ross_1a() {
+    // ['ross-1a', qw(-cs '[:upper:]' '[X*]'),
+    //  {IN=>'AMZamz123.-+AMZ'}, {OUT=>'AMZXAMZ'}],
+    new_ucmd!()
+        .args(&["-cs", "[:upper:]", "[X*]"])
+        .pipe_in("AMZamz123.-+AMZ")
+        .succeeds()
+        .stdout_is("AMZXAMZ");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_ross_1b() {
+    // ['ross-1b', qw(-cs '[:upper:][:digit:]' '[Z*]'), {IN=>''}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-cs", "[:upper:][:digit:]", "[Z*]"])
+        .pipe_in("")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_ross_2() {
+    // ['ross-2', qw(-dcs '[:lower:]' n-rs-z),
+    //  {IN=>'amzAMZ123.-+amz'}, {OUT=>'amzamz'}],
+    new_ucmd!()
+        .args(&["-dcs", "[:lower:]", "n-rs-z"])
+        .pipe_in("amzAMZ123.-+amz")
+        .succeeds()
+        .stdout_is("amzamz");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_ross_3() {
+    // ['ross-3', qw(-ds '[:xdigit:]' '[:alnum:]'),
+    //  {IN=>'.ZABCDEFGzabcdefg.0123456788899.GG'}, {OUT=>'.ZGzg..G'}],
+    new_ucmd!()
+        .args(&["-ds", "[:xdigit:]", "[:alnum:]"])
+        .pipe_in(".ZABCDEFGzabcdefg.0123456788899.GG")
+        .succeeds()
+        .stdout_is(".ZGzg..G");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_ross_4() {
+    // ['ross-4', qw(-dcs '[:alnum:]' '[:digit:]'), {IN=>''}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-dcs", "[:alnum:]", "[:digit:]"])
+        .pipe_in("")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_ross_5() {
+    // ['ross-5', qw(-dc '[:lower:]'), {IN=>''}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-dc", "[:lower:]"])
+        .pipe_in("")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_ross_6() {
+    // ['ross-6', qw(-dc '[:upper:]'), {IN=>''}, {OUT=>''}],
+    new_ucmd!()
+        .args(&["-dc", "[:upper:]"])
+        .pipe_in("")
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_empty_eq() {
+    // # Ensure that these fail.
+    // # Prior to 2.0.20, each would evoke a failed assertion.
+    // ['empty-eq', qw('[==]' x), {IN=>''}, {OUT=>''}, {EXIT=>1},
+    //  {ERR=>"$prog: missing equivalence class character '[==]'\n"}],
+    new_ucmd!()
+        .args(&["[==]", "x"])
+        .pipe_in("")
+        .fails()
+        .stderr_is("tr: missing equivalence class character '[==]'\n");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_empty_cc() {
+    // ['empty-cc', qw('[::]' x), {IN=>''}, {OUT=>''}, {EXIT=>1},
+    //  {ERR=>"$prog: missing character class name '[::]'\n"}],
+    new_ucmd!()
+        .args(&["[::]", "x"])
+        .pipe_in("")
+        .fails()
+        .stderr_is("tr: missing character class name '[::]'\n");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_repeat_bs_9() {
+    // # Weird repeat counts.
+    // ['repeat-bs-9', qw(abc '[b*\9]'), {IN=>'abcd'}, {OUT=>'[b*d'}],
+    new_ucmd!()
+        .args(&["abc", r"[b*\9]"])
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_is("[b*d");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_repeat_0() {
+    // ['repeat-0', qw(abc '[b*0]'), {IN=>'abcd'}, {OUT=>'bbbd'}],
+    new_ucmd!()
+        .args(&["abc", "[b*0]"])
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_is("bbbd");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_repeat_zeros() {
+    // ['repeat-zeros', qw(abc '[b*00000000000000000000]'),
+    //  {IN=>'abcd'}, {OUT=>'bbbd'}],
+    new_ucmd!()
+        .args(&["abc", "[b*00000000000000000000]"])
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_is("bbbd");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_repeat_compl() {
+    // ['repeat-compl', qw(-c '[a*65536]\n' '[b*]'), {IN=>'abcd'}, {OUT=>'abbb'}],
+    new_ucmd!()
+        .args(&["-c", "[a*65536]\n", "[b*]"])
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_is("abbb");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_repeat_x_c() {
+    // ['repeat-xC', qw(-C '[a*65536]\n' '[b*]'), {IN=>'abcd'}, {OUT=>'abbb'}],
+    new_ucmd!()
+        .args(&["-C", "[a*65536]\n", "[b*]"])
+        .pipe_in("abcd")
+        .succeeds()
+        .stdout_is("abbb");
+}
+
+#[test]
+#[ignore = "I think either clap-rs or uutils is parsing the '-H' as an argument..."]
+fn check_against_gnu_tr_tests_fowler_1() {
+    // # From Glenn Fowler.
+    // ['fowler-1', qw(ah -H), {IN=>'aha'}, {OUT=>'-H-'}],
+    new_ucmd!()
+        .args(&["ah", "-H"])
+        .pipe_in("aha")
+        .succeeds()
+        .stdout_is("-H-");
+}
+
+#[test]
+fn check_against_gnu_tr_tests_no_abort_1() {
+    // # Up to coreutils-6.9, this would provoke a failed assertion.
+    // ['no-abort-1', qw(-c a '[b*256]'), {IN=>'abc'}, {OUT=>'abb'}],
+    new_ucmd!()
+        .args(&["-c", "a", "[b*256]"])
+        .pipe_in("abc")
+        .succeeds()
+        .stdout_is("abb");
 }
diff --git a/tests/by-util/test_true.rs b/tests/by-util/test_true.rs
index 1d8622c96..aba32578b 100644
--- a/tests/by-util/test_true.rs
+++ b/tests/by-util/test_true.rs
@@ -1,6 +1,53 @@
 use crate::common::util::*;
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+use std::fs::OpenOptions;
 
 #[test]
 fn test_exit_code() {
     new_ucmd!().succeeds();
 }
+
+#[test]
+fn test_version() {
+    new_ucmd!()
+        .args(&["--version"])
+        .succeeds()
+        .stdout_contains("true");
+}
+
+#[test]
+fn test_help() {
+    new_ucmd!()
+        .args(&["--help"])
+        .succeeds()
+        .stdout_contains("true");
+}
+
+#[test]
+fn test_short_options() {
+    for option in ["-h", "-V"] {
+        new_ucmd!().arg(option).succeeds().stdout_is("");
+    }
+}
+
+#[test]
+fn test_conflict() {
+    new_ucmd!()
+        .args(&["--help", "--version"])
+        .succeeds()
+        .stdout_is("");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+fn test_full() {
+    for option in ["--version", "--help"] {
+        let dev_full = OpenOptions::new().write(true).open("/dev/full").unwrap();
+
+        new_ucmd!()
+            .arg(option)
+            .set_stdout(dev_full)
+            .fails()
+            .stderr_contains("No space left on device");
+    }
+}
diff --git a/tests/by-util/test_truncate.rs b/tests/by-util/test_truncate.rs
index 4b2e9e502..0d3739646 100644
--- a/tests/by-util/test_truncate.rs
+++ b/tests/by-util/test_truncate.rs
@@ -250,11 +250,24 @@ fn test_size_and_reference() {
 #[test]
 fn test_error_filename_only() {
     // truncate: you must specify either '--size' or '--reference'
-    new_ucmd!().args(&["file"]).fails().stderr_contains(
-        "error: The following required arguments were not provided:
+    new_ucmd!()
+        .args(&["file"])
+        .fails()
+        .code_is(1)
+        .stderr_contains(
+            "error: The following required arguments were not provided:
     --reference <RFILE>
     --size <SIZE>",
-    );
+        );
+}
+
+#[test]
+fn test_invalid_option() {
+    // truncate: cli parsing error returns 1
+    new_ucmd!()
+        .args(&["--this-arg-does-not-exist"])
+        .fails()
+        .code_is(1);
 }
 
 #[test]
@@ -306,18 +319,116 @@ fn test_truncate_bytes_size() {
         .fails()
         .code_is(1)
         .stderr_only("truncate: Invalid number: '1Y': Value too large for defined data type");
-    #[cfg(target_pointer_width = "32")]
-    {
-        let sizes = ["1000G", "10T"];
-        for size in &sizes {
-            new_ucmd!()
-                .args(&["--size", size, "file"])
-                .fails()
-                .code_is(1)
-                .stderr_only(format!(
-                    "truncate: Invalid number: '{}': Value too large for defined data type",
-                    size
-                ));
-        }
-    }
+}
+
+/// Test that truncating a non-existent file creates that file.
+#[test]
+fn test_new_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let filename = "new_file_that_does_not_exist_yet";
+    ucmd.args(&["-s", "8", filename])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(at.file_exists(filename));
+    assert_eq!(at.read_bytes(filename), vec![b'\0'; 8]);
+}
+
+/// Test for not creating a non-existent file.
+#[test]
+fn test_new_file_no_create() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let filename = "new_file_that_does_not_exist_yet";
+    ucmd.args(&["-s", "8", "-c", filename])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(!at.file_exists(filename));
+}
+
+#[test]
+fn test_division_by_zero_size_only() {
+    new_ucmd!()
+        .args(&["-s", "/0", "file"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("division by zero");
+    new_ucmd!()
+        .args(&["-s", "%0", "file"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("division by zero");
+}
+
+#[test]
+fn test_division_by_zero_reference_and_size() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.make_file(FILE1);
+    ucmd.args(&["-r", FILE1, "-s", "/0", "file"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("division by zero");
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.make_file(FILE1);
+    ucmd.args(&["-r", FILE1, "-s", "%0", "file"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("division by zero");
+}
+
+#[test]
+fn test_no_such_dir() {
+    new_ucmd!()
+        .args(&["-s", "0", "a/b"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("cannot open 'a/b' for writing: No such file or directory");
+}
+
+/// Test that truncate with a relative size less than 0 is not an error.
+#[test]
+fn test_underflow_relative_size() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-s-1", FILE1])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(at.file_exists(FILE1));
+    assert!(at.read_bytes(FILE1).is_empty());
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_fifo_error_size_only() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkfifo("fifo");
+    ucmd.args(&["-s", "0", "fifo"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("cannot open 'fifo' for writing: No such device or address");
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_fifo_error_reference_file_only() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkfifo("fifo");
+    at.make_file("reference_file");
+    ucmd.args(&["-r", "reference_file", "fifo"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("cannot open 'fifo' for writing: No such device or address");
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_fifo_error_reference_and_size() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkfifo("fifo");
+    at.make_file("reference_file");
+    ucmd.args(&["-r", "reference_file", "-s", "+0", "fifo"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("cannot open 'fifo' for writing: No such device or address");
 }
diff --git a/tests/by-util/test_tty.rs b/tests/by-util/test_tty.rs
index ed490e7ab..09340d39c 100644
--- a/tests/by-util/test_tty.rs
+++ b/tests/by-util/test_tty.rs
@@ -64,6 +64,11 @@ fn test_wrong_argument() {
     new_ucmd!().args(&["a"]).fails().code_is(2);
 }
 
+#[test]
+fn test_help() {
+    new_ucmd!().args(&["--help"]).succeeds();
+}
+
 #[test]
 // FixME: freebsd panic
 #[cfg(all(unix, not(target_os = "freebsd")))]
diff --git a/tests/by-util/test_users.rs b/tests/by-util/test_users.rs
index 1bcbdbdc1..c074f3e40 100644
--- a/tests/by-util/test_users.rs
+++ b/tests/by-util/test_users.rs
@@ -7,6 +7,7 @@ fn test_users_no_arg() {
 
 #[test]
 #[cfg(any(target_vendor = "apple", target_os = "linux"))]
+#[ignore = "issue #3219"]
 fn test_users_check_name() {
     #[cfg(target_os = "linux")]
     let util_name = util_name!();
diff --git a/tests/by-util/test_wc.rs b/tests/by-util/test_wc.rs
index eabaf58eb..1efbe81a7 100644
--- a/tests/by-util/test_wc.rs
+++ b/tests/by-util/test_wc.rs
@@ -1,3 +1,6 @@
+#[cfg(all(unix, not(target_os = "macos")))]
+use pretty_assertions::assert_ne;
+
 use crate::common::util::*;
 
 // spell-checker:ignore (flags) lwmcL clmwL ; (path) bogusfile emptyfile manyemptylines moby notrailingnewline onelongemptyline onelongword weirdchars
@@ -178,7 +181,8 @@ fn test_file_one_long_word() {
         .stdout_is("    1     1 10001 10001 10000 onelongword.txt\n");
 }
 
-/// Test that the number of bytes in the file dictate the display width.
+/// Test that the total size of all the files in the input dictates
+/// the display width.
 ///
 /// The width in digits of any count is the width in digits of the
 /// number of bytes in the file, regardless of whether the number of
@@ -200,6 +204,27 @@ fn test_file_bytes_dictate_width() {
         .args(&["-lw", "emptyfile.txt"])
         .run()
         .stdout_is("0 0 emptyfile.txt\n");
+
+    // lorem_ipsum.txt contains 772 bytes, and alice_in_wonderland.txt contains
+    // 302 bytes. The total is 1074 bytes, which has a width of 4
+    new_ucmd!()
+        .args(&["-lwc", "alice_in_wonderland.txt", "lorem_ipsum.txt"])
+        .run()
+        .stdout_is(
+            "   5   57  302 alice_in_wonderland.txt\n  13  109  772 \
+                    lorem_ipsum.txt\n  18  166 1074 total\n",
+        );
+
+    // . is a directory, so minimum_width should get set to 7
+    #[cfg(not(windows))]
+    const STDOUT: &str = "      0       0       0 emptyfile.txt\n      0       0       0 \
+                          .\n      0       0       0 total\n";
+    #[cfg(windows)]
+    const STDOUT: &str = "      0       0       0 emptyfile.txt\n      0       0       0 total\n";
+    new_ucmd!()
+        .args(&["-lwc", "emptyfile.txt", "."])
+        .run()
+        .stdout_is(STDOUT);
 }
 
 /// Test that getting counts from a directory is an error.
@@ -235,3 +260,64 @@ fn test_read_from_nonexistent_file() {
         .stderr_contains(MSG)
         .stdout_is("");
 }
+
+#[test]
+#[cfg(all(unix, not(target_os = "macos")))]
+fn test_files_from_pseudo_filesystem() {
+    let result = new_ucmd!().arg("-c").arg("/proc/version").succeeds();
+    assert_ne!(result.stdout_str(), "0 /proc/version\n");
+}
+
+#[test]
+fn test_files0_disabled_files_argument() {
+    const MSG: &str = "file operands cannot be combined with --files0-from";
+    new_ucmd!()
+        .args(&["--files0-from=files0_list.txt"])
+        .arg("lorem_ipsum.txt")
+        .fails()
+        .stderr_contains(MSG)
+        .stdout_is("");
+}
+
+#[test]
+fn test_files0_from() {
+    new_ucmd!()
+        .args(&["--files0-from=files0_list.txt"])
+        .run()
+        .stdout_is(
+            "  13  109  772 lorem_ipsum.txt\n  18  204 1115 moby_dick.txt\n   5   57  302 \
+             alice_in_wonderland.txt\n  36  370 2189 total\n",
+        );
+}
+
+#[test]
+fn test_files0_from_with_stdin() {
+    new_ucmd!()
+        .args(&["--files0-from=-"])
+        .pipe_in("lorem_ipsum.txt")
+        .run()
+        .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+}
+
+#[test]
+fn test_files0_from_with_stdin_in_file() {
+    new_ucmd!()
+        .args(&["--files0-from=files0_list_with_stdin.txt"])
+        .pipe_in_fixture("alice_in_wonderland.txt")
+        .run()
+        .stdout_is(
+            "     13     109     772 lorem_ipsum.txt\n     18     204    1115 moby_dick.txt\n      5      57     302 \
+             -\n     36     370    2189 total\n",
+        );
+}
+
+#[test]
+fn test_files0_from_with_stdin_try_read_from_stdin() {
+    const MSG: &str = "when reading file names from stdin, no file name of '-' allowed";
+    new_ucmd!()
+        .args(&["--files0-from=-"])
+        .pipe_in("-")
+        .fails()
+        .stderr_contains(MSG)
+        .stdout_is("");
+}
diff --git a/tests/by-util/test_who.rs b/tests/by-util/test_who.rs
index d05715517..65773655d 100644
--- a/tests/by-util/test_who.rs
+++ b/tests/by-util/test_who.rs
@@ -9,9 +9,10 @@ use crate::common::util::*;
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_count() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-q", "--count"] {
+    for opt in &["-q", "--count", "--c"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -21,7 +22,7 @@ fn test_count() {
 #[test]
 fn test_boot() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-b", "--boot"] {
+    for opt in &["-b", "--boot", "--b"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -29,9 +30,10 @@ fn test_boot() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_heading() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-H", "--heading"] {
+    for opt in &["-H", "--heading", "--head"] {
         // allow whitespace variation
         // * minor whitespace differences occur between platform built-in outputs;
         //   specifically number of TABs between "TIME" and "COMMENT" may be variant
@@ -47,9 +49,10 @@ fn test_heading() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_short() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-s", "--short"] {
+    for opt in &["-s", "--short", "--s"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -59,7 +62,7 @@ fn test_short() {
 #[test]
 fn test_login() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-l", "--login"] {
+    for opt in &["-l", "--login", "--log"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -69,17 +72,15 @@ fn test_login() {
 #[test]
 fn test_m() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-m"] {
-        let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
-        ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
-    }
+    let expected_stdout = unwrap_or_return!(expected_result(&ts, &["-m"])).stdout_move_str();
+    ts.ucmd().arg("-m").succeeds().stdout_is(expected_stdout);
 }
 
 #[cfg(unix)]
 #[test]
 fn test_process() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-p", "--process"] {
+    for opt in &["-p", "--process", "--p"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -89,7 +90,7 @@ fn test_process() {
 #[test]
 fn test_runlevel() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-r", "--runlevel"] {
+    for opt in &["-r", "--runlevel", "--r"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
 
@@ -102,7 +103,7 @@ fn test_runlevel() {
 #[test]
 fn test_time() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-t", "--time"] {
+    for opt in &["-t", "--time", "--t"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -110,6 +111,7 @@ fn test_time() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_mesg() {
     // -T, -w, --mesg
     //     add user's message status as +, - or ?
@@ -118,7 +120,15 @@ fn test_mesg() {
     // --writable
     //     same as -T
     let ts = TestScenario::new(util_name!());
-    for opt in &["-T", "-w", "--mesg", "--message", "--writable"] {
+    for opt in &[
+        "-T",
+        "-w",
+        "--mesg",
+        "--m",
+        "--message",
+        "--writable",
+        "--w",
+    ] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -136,7 +146,7 @@ fn test_arg1_arg2() {
 #[test]
 fn test_too_many_args() {
     const EXPECTED: &str =
-        "error: The value 'u' was provided to '<FILE>...', but it wasn't expecting any more values";
+        "error: The value 'u' was provided to '<FILE>...' but it wasn't expecting any more values";
 
     let args = ["am", "i", "u"];
     new_ucmd!().args(&args).fails().stderr_contains(EXPECTED);
@@ -144,9 +154,10 @@ fn test_too_many_args() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_users() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-u", "--users"] {
+    for opt in &["-u", "--users", "--us"] {
         let actual = ts.ucmd().arg(opt).succeeds().stdout_move_str();
         let expect = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         println!("actual: {:?}", actual);
@@ -169,6 +180,7 @@ fn test_users() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_lookup() {
     let opt = "--lookup";
     let ts = TestScenario::new(util_name!());
@@ -180,7 +192,7 @@ fn test_lookup() {
 #[test]
 fn test_dead() {
     let ts = TestScenario::new(util_name!());
-    for opt in &["-d", "--dead"] {
+    for opt in &["-d", "--dead", "--de"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
@@ -188,6 +200,7 @@ fn test_dead() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_all_separately() {
     if cfg!(target_os = "macos") {
         // TODO: fix `-u`, see: test_users
@@ -205,6 +218,7 @@ fn test_all_separately() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "issue #3219"]
 fn test_all() {
     if cfg!(target_os = "macos") {
         // TODO: fix `-u`, see: test_users
@@ -212,7 +226,7 @@ fn test_all() {
     }
 
     let ts = TestScenario::new(util_name!());
-    for opt in &["-a", "--all"] {
+    for opt in &["-a", "--all", "--a"] {
         let expected_stdout = unwrap_or_return!(expected_result(&ts, &[opt])).stdout_move_str();
         ts.ucmd().arg(opt).succeeds().stdout_is(expected_stdout);
     }
diff --git a/tests/by-util/test_yes.rs b/tests/by-util/test_yes.rs
index 7e950e1ea..38165e92b 100644
--- a/tests/by-util/test_yes.rs
+++ b/tests/by-util/test_yes.rs
@@ -45,7 +45,7 @@ fn test_long_input() {
     // try something long.
     #[cfg(windows)]
     const TIMES: usize = 500;
-    let arg = "abcdefg".repeat(TIMES) + "\n";
+    let arg = "abcdef".repeat(TIMES) + "\n";
     let expected_out = arg.repeat(30);
     run(&[&arg[..arg.len() - 1]], expected_out.as_bytes());
 }
diff --git a/tests/common/util.rs b/tests/common/util.rs
index c7ac816e1..5e1424ca4 100644
--- a/tests/common/util.rs
+++ b/tests/common/util.rs
@@ -62,6 +62,10 @@ fn read_scenario_fixture<S: AsRef<OsStr>>(tmpd: &Option<Rc<TempDir>>, file_rel_p
 /// within a struct which has convenience assertion functions about those outputs
 #[derive(Debug, Clone)]
 pub struct CmdResult {
+    /// bin_path provided by `TestScenario` or `UCommand`
+    bin_path: String,
+    /// util_name provided by `TestScenario` or `UCommand`
+    util_name: Option<String>,
     //tmpd is used for convenience functions for asserts against fixtures
     tmpd: Option<Rc<TempDir>>,
     /// exit status for command (if there is one)
@@ -77,13 +81,17 @@ pub struct CmdResult {
 
 impl CmdResult {
     pub fn new(
+        bin_path: String,
+        util_name: Option<String>,
         tmpd: Option<Rc<TempDir>>,
         code: Option<i32>,
         success: bool,
         stdout: &[u8],
         stderr: &[u8],
-    ) -> CmdResult {
-        CmdResult {
+    ) -> Self {
+        Self {
+            bin_path,
+            util_name,
             tmpd,
             code,
             success,
@@ -142,7 +150,7 @@ impl CmdResult {
         self.code.expect("Program must be run first")
     }
 
-    pub fn code_is(&self, expected_code: i32) -> &CmdResult {
+    pub fn code_is(&self, expected_code: i32) -> &Self {
         assert_eq!(self.code(), expected_code);
         self
     }
@@ -162,7 +170,7 @@ impl CmdResult {
     }
 
     /// asserts that the command resulted in a success (zero) status code
-    pub fn success(&self) -> &CmdResult {
+    pub fn success(&self) -> &Self {
         assert!(
             self.success,
             "Command was expected to succeed.\nstdout = {}\n stderr = {}",
@@ -173,7 +181,7 @@ impl CmdResult {
     }
 
     /// asserts that the command resulted in a failure (non-zero) status code
-    pub fn failure(&self) -> &CmdResult {
+    pub fn failure(&self) -> &Self {
         assert!(
             !self.success,
             "Command was expected to fail.\nstdout = {}\n stderr = {}",
@@ -184,7 +192,7 @@ impl CmdResult {
     }
 
     /// asserts that the command's exit code is the same as the given one
-    pub fn status_code(&self, code: i32) -> &CmdResult {
+    pub fn status_code(&self, code: i32) -> &Self {
         assert_eq!(self.code, Some(code));
         self
     }
@@ -194,7 +202,7 @@ impl CmdResult {
     /// but you might find yourself using this function if
     /// 1.  you can not know exactly what stdout will be or
     /// 2.  you know that stdout will also be empty
-    pub fn no_stderr(&self) -> &CmdResult {
+    pub fn no_stderr(&self) -> &Self {
         assert!(
             self.stderr.is_empty(),
             "Expected stderr to be empty, but it's:\n{}",
@@ -209,7 +217,7 @@ impl CmdResult {
     /// but you might find yourself using this function if
     /// 1.  you can not know exactly what stderr will be or
     /// 2.  you know that stderr will also be empty
-    pub fn no_stdout(&self) -> &CmdResult {
+    pub fn no_stdout(&self) -> &Self {
         assert!(
             self.stdout.is_empty(),
             "Expected stdout to be empty, but it's:\n{}",
@@ -221,25 +229,25 @@ impl CmdResult {
     /// asserts that the command resulted in stdout stream output that equals the
     /// passed in value, trailing whitespace are kept to force strict comparison (#1235)
     /// stdout_only is a better choice unless stderr may or will be non-empty
-    pub fn stdout_is<T: AsRef<str>>(&self, msg: T) -> &CmdResult {
+    pub fn stdout_is<T: AsRef<str>>(&self, msg: T) -> &Self {
         assert_eq!(self.stdout_str(), String::from(msg.as_ref()));
         self
     }
 
     /// like `stdout_is`, but succeeds if any elements of `expected` matches stdout.
-    pub fn stdout_is_any<T: AsRef<str> + std::fmt::Debug>(&self, expected: Vec<T>) -> &CmdResult {
+    pub fn stdout_is_any<T: AsRef<str> + std::fmt::Debug>(&self, expected: &[T]) -> &Self {
         if !expected.iter().any(|msg| self.stdout_str() == msg.as_ref()) {
             panic!(
                 "stdout was {}\nExpected any of {:#?}",
                 self.stdout_str(),
                 expected
-            )
+            );
         }
         self
     }
 
     /// Like `stdout_is` but newlines are normalized to `\n`.
-    pub fn normalized_newlines_stdout_is<T: AsRef<str>>(&self, msg: T) -> &CmdResult {
+    pub fn normalized_newlines_stdout_is<T: AsRef<str>>(&self, msg: T) -> &Self {
         let msg = msg.as_ref().replace("\r\n", "\n");
         assert_eq!(self.stdout_str().replace("\r\n", "\n"), msg);
         self
@@ -247,23 +255,45 @@ impl CmdResult {
 
     /// asserts that the command resulted in stdout stream output,
     /// whose bytes equal those of the passed in slice
-    pub fn stdout_is_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &CmdResult {
+    pub fn stdout_is_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &Self {
         assert_eq!(self.stdout, msg.as_ref());
         self
     }
 
     /// like stdout_is(...), but expects the contents of the file at the provided relative path
-    pub fn stdout_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &CmdResult {
+    pub fn stdout_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
         let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
         self.stdout_is(String::from_utf8(contents).unwrap())
     }
+
+    /// Assert that the bytes of stdout exactly match those of the given file.
+    ///
+    /// Contrast this with [`CmdResult::stdout_is_fixture`], which
+    /// decodes the contents of the file as a UTF-8 [`String`] before
+    /// comparison with stdout.
+    ///
+    /// # Examples
+    ///
+    /// Use this method in a unit test like this:
+    ///
+    /// ```rust,ignore
+    /// #[test]
+    /// fn test_something() {
+    ///     new_ucmd!().succeeds().stdout_is_fixture_bytes("expected.bin");
+    /// }
+    /// ```
+    pub fn stdout_is_fixture_bytes<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
+        let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
+        self.stdout_is_bytes(contents)
+    }
+
     /// like stdout_is_fixture(...), but replaces the data in fixture file based on values provided in template_vars
     /// command output
     pub fn stdout_is_templated_fixture<T: AsRef<OsStr>>(
         &self,
         file_rel_path: T,
         template_vars: &[(&str, &str)],
-    ) -> &CmdResult {
+    ) -> &Self {
         let mut contents =
             String::from_utf8(read_scenario_fixture(&self.tmpd, file_rel_path)).unwrap();
         for kv in template_vars {
@@ -286,13 +316,13 @@ impl CmdResult {
             }
             contents
         });
-        self.stdout_is_any(possible_values.collect());
+        self.stdout_is_any(&possible_values.collect::<Vec<_>>());
     }
 
     /// asserts that the command resulted in stderr stream output that equals the
     /// passed in value, when both are trimmed of trailing whitespace
     /// stderr_only is a better choice unless stdout may or will be non-empty
-    pub fn stderr_is<T: AsRef<str>>(&self, msg: T) -> &CmdResult {
+    pub fn stderr_is<T: AsRef<str>>(&self, msg: T) -> &Self {
         assert_eq!(
             self.stderr_str().trim_end(),
             String::from(msg.as_ref()).trim_end()
@@ -302,13 +332,13 @@ impl CmdResult {
 
     /// asserts that the command resulted in stderr stream output,
     /// whose bytes equal those of the passed in slice
-    pub fn stderr_is_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &CmdResult {
+    pub fn stderr_is_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &Self {
         assert_eq!(self.stderr, msg.as_ref());
         self
     }
 
     /// Like stdout_is_fixture, but for stderr
-    pub fn stderr_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &CmdResult {
+    pub fn stderr_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
         let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
         self.stderr_is(String::from_utf8(contents).unwrap())
     }
@@ -317,7 +347,7 @@ impl CmdResult {
     /// 1.  the command resulted in stdout stream output that equals the
     ///     passed in value
     /// 2.  the command resulted in empty (zero-length) stderr stream output
-    pub fn stdout_only<T: AsRef<str>>(&self, msg: T) -> &CmdResult {
+    pub fn stdout_only<T: AsRef<str>>(&self, msg: T) -> &Self {
         self.no_stderr().stdout_is(msg)
     }
 
@@ -325,12 +355,12 @@ impl CmdResult {
     /// 1.  the command resulted in a stdout stream whose bytes
     ///     equal those of the passed in value
     /// 2.  the command resulted in an empty stderr stream
-    pub fn stdout_only_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &CmdResult {
+    pub fn stdout_only_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &Self {
         self.no_stderr().stdout_is_bytes(msg)
     }
 
     /// like stdout_only(...), but expects the contents of the file at the provided relative path
-    pub fn stdout_only_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &CmdResult {
+    pub fn stdout_only_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
         let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
         self.stdout_only_bytes(contents)
     }
@@ -339,7 +369,7 @@ impl CmdResult {
     /// 1.  the command resulted in stderr stream output that equals the
     ///     passed in value, when both are trimmed of trailing whitespace
     /// 2.  the command resulted in empty (zero-length) stdout stream output
-    pub fn stderr_only<T: AsRef<str>>(&self, msg: T) -> &CmdResult {
+    pub fn stderr_only<T: AsRef<str>>(&self, msg: T) -> &Self {
         self.no_stdout().stderr_is(msg)
     }
 
@@ -347,17 +377,34 @@ impl CmdResult {
     /// 1.  the command resulted in a stderr stream whose bytes equal the ones
     ///     of the passed value
     /// 2.  the command resulted in an empty stdout stream
-    pub fn stderr_only_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &CmdResult {
-        self.no_stderr().stderr_is_bytes(msg)
+    pub fn stderr_only_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &Self {
+        self.no_stdout().stderr_is_bytes(msg)
     }
 
-    pub fn fails_silently(&self) -> &CmdResult {
+    pub fn fails_silently(&self) -> &Self {
         assert!(!self.success);
         assert!(self.stderr.is_empty());
         self
     }
 
-    pub fn stdout_contains<T: AsRef<str>>(&self, cmp: T) -> &CmdResult {
+    /// asserts that
+    /// 1.  the command resulted in stderr stream output that equals the
+    ///     the following format when both are trimmed of trailing whitespace
+    ///     `"{util_name}: {msg}\nTry '{bin_path} {util_name} --help' for more information."`
+    ///     This the expected format when a UUsageError is returned or when show_error! is called
+    ///     `msg` should be the same as the one provided to UUsageError::new or show_error!
+    ///
+    /// 2.  the command resulted in empty (zero-length) stdout stream output
+    pub fn usage_error<T: AsRef<str>>(&self, msg: T) -> &Self {
+        self.stderr_only(format!(
+            "{0}: {2}\nTry '{1} {0} --help' for more information.",
+            self.util_name.as_ref().unwrap(), // This shouldn't be called using a normal command
+            self.bin_path,
+            msg.as_ref()
+        ))
+    }
+
+    pub fn stdout_contains<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(
             self.stdout_str().contains(cmp.as_ref()),
             "'{}' does not contain '{}'",
@@ -367,7 +414,7 @@ impl CmdResult {
         self
     }
 
-    pub fn stderr_contains<T: AsRef<str>>(&self, cmp: T) -> &CmdResult {
+    pub fn stderr_contains<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(
             self.stderr_str().contains(cmp.as_ref()),
             "'{}' does not contain '{}'",
@@ -377,7 +424,7 @@ impl CmdResult {
         self
     }
 
-    pub fn stdout_does_not_contain<T: AsRef<str>>(&self, cmp: T) -> &CmdResult {
+    pub fn stdout_does_not_contain<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(
             !self.stdout_str().contains(cmp.as_ref()),
             "'{}' contains '{}' but should not",
@@ -387,21 +434,21 @@ impl CmdResult {
         self
     }
 
-    pub fn stderr_does_not_contain<T: AsRef<str>>(&self, cmp: T) -> &CmdResult {
+    pub fn stderr_does_not_contain<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(!self.stderr_str().contains(cmp.as_ref()));
         self
     }
 
-    pub fn stdout_matches(&self, regex: &regex::Regex) -> &CmdResult {
+    pub fn stdout_matches(&self, regex: &regex::Regex) -> &Self {
         if !regex.is_match(self.stdout_str().trim()) {
-            panic!("Stdout does not match regex:\n{}", self.stdout_str())
+            panic!("Stdout does not match regex:\n{}", self.stdout_str());
         }
         self
     }
 
-    pub fn stdout_does_not_match(&self, regex: &regex::Regex) -> &CmdResult {
+    pub fn stdout_does_not_match(&self, regex: &regex::Regex) -> &Self {
         if regex.is_match(self.stdout_str().trim()) {
-            panic!("Stdout matches regex:\n{}", self.stdout_str())
+            panic!("Stdout matches regex:\n{}", self.stdout_str());
         }
         self
     }
@@ -444,8 +491,8 @@ pub struct AtPath {
 }
 
 impl AtPath {
-    pub fn new(subdir: &Path) -> AtPath {
-        AtPath {
+    pub fn new(subdir: &Path) -> Self {
+        Self {
             subdir: PathBuf::from(subdir),
         }
     }
@@ -654,6 +701,11 @@ impl AtPath {
         symlink_file(&self.plus(original), &self.plus(link)).unwrap();
     }
 
+    pub fn relative_symlink_file(&self, original: &str, link: &str) {
+        log_info("symlink", &format!("{},{}", original, link));
+        symlink_file(original, link).unwrap();
+    }
+
     pub fn symlink_dir(&self, original: &str, link: &str) {
         log_info(
             "symlink",
@@ -728,20 +780,12 @@ impl AtPath {
         // Source:
         // http://stackoverflow.com/questions/31439011/getfinalpathnamebyhandle-without-prepended
         let prefix = "\\\\?\\";
-        // FixME: replace ...
-        #[allow(clippy::manual_strip)]
-        if s.starts_with(prefix) {
-            String::from(&s[prefix.len()..])
+
+        if let Some(stripped) = s.strip_prefix(prefix) {
+            String::from(stripped)
         } else {
             s
         }
-        // ... with ...
-        // if let Some(stripped) = s.strip_prefix(prefix) {
-        //     String::from(stripped)
-        // } else {
-        //     s
-        // }
-        // ... when using MSRV with stabilized `strip_prefix()`
     }
 }
 
@@ -759,9 +803,9 @@ pub struct TestScenario {
 }
 
 impl TestScenario {
-    pub fn new(util_name: &str) -> TestScenario {
+    pub fn new(util_name: &str) -> Self {
         let tmpd = Rc::new(TempDir::new().unwrap());
-        let ts = TestScenario {
+        let ts = Self {
             bin_path: {
                 // Instead of hard coding the path relative to the current
                 // directory, use Cargo's OUT_DIR to find path to executable.
@@ -788,31 +832,36 @@ impl TestScenario {
     /// Returns builder for invoking the target uutils binary. Paths given are
     /// treated relative to the environment's unique temporary test directory.
     pub fn ucmd(&self) -> UCommand {
-        let mut cmd = self.cmd(&self.bin_path);
-        cmd.arg(&self.util_name);
-        cmd
+        self.composite_cmd(&self.bin_path, &self.util_name, true)
+    }
+
+    /// Returns builder for invoking the target uutils binary. Paths given are
+    /// treated relative to the environment's unique temporary test directory.
+    pub fn composite_cmd<S: AsRef<OsStr>, T: AsRef<OsStr>>(
+        &self,
+        bin: S,
+        util_name: T,
+        env_clear: bool,
+    ) -> UCommand {
+        UCommand::new_from_tmp(bin, &Some(util_name), self.tmpd.clone(), env_clear)
     }
 
     /// Returns builder for invoking any system command. Paths given are treated
     /// relative to the environment's unique temporary test directory.
     pub fn cmd<S: AsRef<OsStr>>(&self, bin: S) -> UCommand {
-        UCommand::new_from_tmp(bin, self.tmpd.clone(), true)
+        UCommand::new_from_tmp::<S, S>(bin, &None, self.tmpd.clone(), true)
     }
 
     /// Returns builder for invoking any uutils command. Paths given are treated
     /// relative to the environment's unique temporary test directory.
     pub fn ccmd<S: AsRef<OsStr>>(&self, bin: S) -> UCommand {
-        let mut cmd = self.cmd(&self.bin_path);
-        cmd.arg(bin);
-        cmd
+        self.composite_cmd(&self.bin_path, bin, true)
     }
 
     // different names are used rather than an argument
     // because the need to keep the environment is exceedingly rare.
     pub fn ucmd_keepenv(&self) -> UCommand {
-        let mut cmd = self.cmd_keepenv(&self.bin_path);
-        cmd.arg(&self.util_name);
-        cmd
+        self.composite_cmd(&self.bin_path, &self.util_name, false)
     }
 
     /// Returns builder for invoking any system command. Paths given are treated
@@ -820,7 +869,7 @@ impl TestScenario {
     /// Differs from the builder returned by `cmd` in that `cmd_keepenv` does not call
     /// `Command::env_clear` (Clears the entire environment map for the child process.)
     pub fn cmd_keepenv<S: AsRef<OsStr>>(&self, bin: S) -> UCommand {
-        UCommand::new_from_tmp(bin, self.tmpd.clone(), false)
+        UCommand::new_from_tmp::<S, S>(bin, &None, self.tmpd.clone(), false)
     }
 }
 
@@ -834,6 +883,8 @@ impl TestScenario {
 pub struct UCommand {
     pub raw: Command,
     comm_string: String,
+    bin_path: String,
+    util_name: Option<String>,
     tmpd: Option<Rc<TempDir>>,
     has_run: bool,
     ignore_stdin_write_error: bool,
@@ -846,12 +897,20 @@ pub struct UCommand {
 }
 
 impl UCommand {
-    pub fn new<T: AsRef<OsStr>, U: AsRef<OsStr>>(arg: T, curdir: U, env_clear: bool) -> UCommand {
-        UCommand {
+    pub fn new<T: AsRef<OsStr>, S: AsRef<OsStr>, U: AsRef<OsStr>>(
+        bin_path: T,
+        util_name: &Option<S>,
+        curdir: U,
+        env_clear: bool,
+    ) -> Self {
+        let bin_path = bin_path.as_ref();
+        let util_name = util_name.as_ref().map(|un| un.as_ref());
+
+        let mut ucmd = Self {
             tmpd: None,
             has_run: false,
             raw: {
-                let mut cmd = Command::new(arg.as_ref());
+                let mut cmd = Command::new(bin_path);
                 cmd.current_dir(curdir.as_ref());
                 if env_clear {
                     if cfg!(windows) {
@@ -871,7 +930,9 @@ impl UCommand {
                 }
                 cmd
             },
-            comm_string: String::from(arg.as_ref().to_str().unwrap()),
+            comm_string: String::from(bin_path.to_str().unwrap()),
+            bin_path: bin_path.to_str().unwrap().to_string(),
+            util_name: util_name.map(|un| un.to_str().unwrap().to_string()),
             ignore_stdin_write_error: false,
             bytes_into_stdin: None,
             stdin: None,
@@ -879,34 +940,45 @@ impl UCommand {
             stderr: None,
             #[cfg(target_os = "linux")]
             limits: vec![],
+        };
+
+        if let Some(un) = util_name {
+            ucmd.arg(un);
         }
+
+        ucmd
     }
 
-    pub fn new_from_tmp<T: AsRef<OsStr>>(arg: T, tmpd: Rc<TempDir>, env_clear: bool) -> UCommand {
+    pub fn new_from_tmp<T: AsRef<OsStr>, S: AsRef<OsStr>>(
+        bin_path: T,
+        util_name: &Option<S>,
+        tmpd: Rc<TempDir>,
+        env_clear: bool,
+    ) -> Self {
         let tmpd_path_buf = String::from(&(*tmpd.as_ref().path().to_str().unwrap()));
-        let mut ucmd: UCommand = UCommand::new(arg.as_ref(), tmpd_path_buf, env_clear);
+        let mut ucmd: Self = Self::new(bin_path, util_name, tmpd_path_buf, env_clear);
         ucmd.tmpd = Some(tmpd);
         ucmd
     }
 
-    pub fn set_stdin<T: Into<Stdio>>(&mut self, stdin: T) -> &mut UCommand {
+    pub fn set_stdin<T: Into<Stdio>>(&mut self, stdin: T) -> &mut Self {
         self.stdin = Some(stdin.into());
         self
     }
 
-    pub fn set_stdout<T: Into<Stdio>>(&mut self, stdout: T) -> &mut UCommand {
+    pub fn set_stdout<T: Into<Stdio>>(&mut self, stdout: T) -> &mut Self {
         self.stdout = Some(stdout.into());
         self
     }
 
-    pub fn set_stderr<T: Into<Stdio>>(&mut self, stderr: T) -> &mut UCommand {
+    pub fn set_stderr<T: Into<Stdio>>(&mut self, stderr: T) -> &mut Self {
         self.stderr = Some(stderr.into());
         self
     }
 
     /// Add a parameter to the invocation. Path arguments are treated relative
     /// to the test environment directory.
-    pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut UCommand {
+    pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self {
         assert!(!self.has_run, "{}", ALREADY_RUN);
         self.comm_string.push(' ');
         self.comm_string
@@ -917,7 +989,7 @@ impl UCommand {
 
     /// Add multiple parameters to the invocation. Path arguments are treated relative
     /// to the test environment directory.
-    pub fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut UCommand {
+    pub fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut Self {
         assert!(!self.has_run, "{}", MULTIPLE_STDIN_MEANINGLESS);
         let strings = args
             .iter()
@@ -935,9 +1007,9 @@ impl UCommand {
     }
 
     /// provides standard input to feed in to the command when spawned
-    pub fn pipe_in<T: Into<Vec<u8>>>(&mut self, input: T) -> &mut UCommand {
+    pub fn pipe_in<T: Into<Vec<u8>>>(&mut self, input: T) -> &mut Self {
         assert!(
-            !self.bytes_into_stdin.is_some(),
+            self.bytes_into_stdin.is_none(),
             "{}",
             MULTIPLE_STDIN_MEANINGLESS
         );
@@ -946,7 +1018,7 @@ impl UCommand {
     }
 
     /// like pipe_in(...), but uses the contents of the file at the provided relative path as the piped in data
-    pub fn pipe_in_fixture<S: AsRef<OsStr>>(&mut self, file_rel_path: S) -> &mut UCommand {
+    pub fn pipe_in_fixture<S: AsRef<OsStr>>(&mut self, file_rel_path: S) -> &mut Self {
         let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
         self.pipe_in(contents)
     }
@@ -954,13 +1026,13 @@ impl UCommand {
     /// Ignores error caused by feeding stdin to the command.
     /// This is typically useful to test non-standard workflows
     /// like feeding something to a command that does not read it
-    pub fn ignore_stdin_write_error(&mut self) -> &mut UCommand {
-        assert!(!self.bytes_into_stdin.is_none(), "{}", NO_STDIN_MEANINGLESS);
+    pub fn ignore_stdin_write_error(&mut self) -> &mut Self {
+        assert!(self.bytes_into_stdin.is_some(), "{}", NO_STDIN_MEANINGLESS);
         self.ignore_stdin_write_error = true;
         self
     }
 
-    pub fn env<K, V>(&mut self, key: K, val: V) -> &mut UCommand
+    pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Self
     where
         K: AsRef<OsStr>,
         V: AsRef<OsStr>,
@@ -1014,7 +1086,7 @@ impl UCommand {
                 .write_all(input);
             if !self.ignore_stdin_write_error {
                 if let Err(e) = write_result {
-                    panic!("failed to write to stdin of child: {}", e)
+                    panic!("failed to write to stdin of child: {}", e);
                 }
             }
         }
@@ -1029,6 +1101,8 @@ impl UCommand {
         let prog = self.run_no_wait().wait_with_output().unwrap();
 
         CmdResult {
+            bin_path: self.bin_path.clone(),
+            util_name: self.util_name.clone(),
             tmpd: self.tmpd.clone(),
             code: prog.status.code(),
             success: prog.status.success(),
@@ -1070,6 +1144,13 @@ impl UCommand {
 /// Wrapper for `child.stdout.read_exact()`.
 /// Careful, this blocks indefinitely if `size` bytes is never reached.
 pub fn read_size(child: &mut Child, size: usize) -> String {
+    String::from_utf8(read_size_bytes(child, size)).unwrap()
+}
+
+/// Read the specified number of bytes from the stdout of the child process.
+///
+/// Careful, this blocks indefinitely if `size` bytes is never reached.
+pub fn read_size_bytes(child: &mut Child, size: usize) -> Vec<u8> {
     let mut output = Vec::new();
     output.resize(size, 0);
     sleep(Duration::from_secs(1));
@@ -1079,7 +1160,7 @@ pub fn read_size(child: &mut Child, size: usize) -> String {
         .unwrap()
         .read_exact(output.as_mut_slice())
         .unwrap();
-    String::from_utf8(output).unwrap()
+    output
 }
 
 pub fn vec_of_size(n: usize) -> Vec<u8> {
@@ -1119,13 +1200,13 @@ pub fn host_name_for(util_name: &str) -> Cow<str> {
     {
         // make call to `host_name_for` idempotent
         if util_name.starts_with('g') && util_name != "groups" {
-            return util_name.into();
+            util_name.into()
         } else {
-            return format!("g{}", util_name).into();
+            format!("g{}", util_name).into()
         }
     }
     #[cfg(target_os = "linux")]
-    return util_name.into();
+    util_name.into()
 }
 
 // GNU coreutils version 8.32 is the reference version since it is the latest version and the
@@ -1183,14 +1264,7 @@ pub fn check_coreutil_version(
         .output()
     {
         Ok(s) => s,
-        Err(e) => {
-            return Err(format!(
-                "{}: '{}' {}",
-                UUTILS_WARNING,
-                util_name,
-                e.to_string()
-            ))
-        }
+        Err(e) => return Err(format!("{}: '{}' {}", UUTILS_WARNING, util_name, e)),
     };
     std::str::from_utf8(&version_check.stdout).unwrap()
         .split('\n')
@@ -1200,7 +1274,7 @@ pub fn check_coreutil_version(
             || Err(format!("{}: unexpected output format for reference coreutil: '{} --version'", UUTILS_WARNING, util_name)),
             |s| {
                 if s.contains(&format!("(GNU coreutils) {}", version_expected)) {
-                    Ok(format!("{}: {}", UUTILS_INFO, s.to_string()))
+                    Ok(format!("{}: {}", UUTILS_INFO, s))
                 } else if s.contains("(GNU coreutils)") {
                     let version_found = parse_coreutil_version(s);
                     let version_expected = version_expected.parse::<f32>().unwrap_or_default();
@@ -1276,6 +1350,8 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
     };
 
     Ok(CmdResult::new(
+        ts.bin_path.as_os_str().to_str().unwrap().to_string(),
+        Some(ts.util_name.clone()),
         Some(result.tmpd()),
         Some(result.code()),
         result.succeeded(),
@@ -1293,6 +1369,8 @@ mod tests {
     #[test]
     fn test_code_is() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: Some(32),
             success: false,
@@ -1306,6 +1384,8 @@ mod tests {
     #[should_panic]
     fn test_code_is_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: Some(32),
             success: false,
@@ -1318,6 +1398,8 @@ mod tests {
     #[test]
     fn test_failure() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: false,
@@ -1331,6 +1413,8 @@ mod tests {
     #[should_panic]
     fn test_failure_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1343,6 +1427,8 @@ mod tests {
     #[test]
     fn test_success() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1356,6 +1442,8 @@ mod tests {
     #[should_panic]
     fn test_success_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: false,
@@ -1368,6 +1456,8 @@ mod tests {
     #[test]
     fn test_no_stderr_output() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1382,6 +1472,8 @@ mod tests {
     #[should_panic]
     fn test_no_stderr_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1396,6 +1488,8 @@ mod tests {
     #[should_panic]
     fn test_no_stdout_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1409,6 +1503,8 @@ mod tests {
     #[test]
     fn test_std_does_not_contain() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1423,6 +1519,8 @@ mod tests {
     #[should_panic]
     fn test_stdout_does_not_contain_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1437,6 +1535,8 @@ mod tests {
     #[should_panic]
     fn test_stderr_does_not_contain_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1450,6 +1550,8 @@ mod tests {
     #[test]
     fn test_stdout_matches() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1466,6 +1568,8 @@ mod tests {
     #[should_panic]
     fn test_stdout_matches_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1481,6 +1585,8 @@ mod tests {
     #[should_panic]
     fn test_stdout_not_matches_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1495,6 +1601,8 @@ mod tests {
     #[test]
     fn test_normalized_newlines_stdout_is() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
@@ -1511,6 +1619,8 @@ mod tests {
     #[should_panic]
     fn test_normalized_newlines_stdout_is_fail() {
         let res = CmdResult {
+            bin_path: "".into(),
+            util_name: None,
             tmpd: None,
             code: None,
             success: true,
diff --git a/src/uu/dd/test-resources/all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test b/tests/fixtures/dd/all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test
similarity index 100%
rename from src/uu/dd/test-resources/all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test
rename to tests/fixtures/dd/all-valid-ascii-chars-37eff01866ba3f538421b30b7cbefcac.test
diff --git a/src/uu/dd/test-resources/dd-block-cbs16-win.test b/tests/fixtures/dd/dd-block-cbs16-win.test
similarity index 100%
rename from src/uu/dd/test-resources/dd-block-cbs16-win.test
rename to tests/fixtures/dd/dd-block-cbs16-win.test
diff --git a/src/uu/dd/test-resources/dd-block-cbs16.spec b/tests/fixtures/dd/dd-block-cbs16.spec
similarity index 100%
rename from src/uu/dd/test-resources/dd-block-cbs16.spec
rename to tests/fixtures/dd/dd-block-cbs16.spec
diff --git a/src/uu/dd/test-resources/dd-block-cbs16.test b/tests/fixtures/dd/dd-block-cbs16.test
similarity index 100%
rename from src/uu/dd/test-resources/dd-block-cbs16.test
rename to tests/fixtures/dd/dd-block-cbs16.test
diff --git a/src/uu/dd/test-resources/dd-block-cbs8.spec b/tests/fixtures/dd/dd-block-cbs8.spec
similarity index 100%
rename from src/uu/dd/test-resources/dd-block-cbs8.spec
rename to tests/fixtures/dd/dd-block-cbs8.spec
diff --git a/src/uu/dd/test-resources/dd-block-consecutive-nl-cbs16.spec b/tests/fixtures/dd/dd-block-consecutive-nl-cbs16.spec
similarity index 100%
rename from src/uu/dd/test-resources/dd-block-consecutive-nl-cbs16.spec
rename to tests/fixtures/dd/dd-block-consecutive-nl-cbs16.spec
diff --git a/src/uu/dd/test-resources/dd-block-consecutive-nl-win.test b/tests/fixtures/dd/dd-block-consecutive-nl-win.test
similarity index 100%
rename from src/uu/dd/test-resources/dd-block-consecutive-nl-win.test
rename to tests/fixtures/dd/dd-block-consecutive-nl-win.test
diff --git a/src/uu/dd/test-resources/dd-block-consecutive-nl.test b/tests/fixtures/dd/dd-block-consecutive-nl.test
similarity index 100%
rename from src/uu/dd/test-resources/dd-block-consecutive-nl.test
rename to tests/fixtures/dd/dd-block-consecutive-nl.test
diff --git a/tests/fixtures/dd/dd-bytes-alphabet-null.spec b/tests/fixtures/dd/dd-bytes-alphabet-null.spec
new file mode 100644
index 000000000..1ab5429c1
Binary files /dev/null and b/tests/fixtures/dd/dd-bytes-alphabet-null.spec differ
diff --git a/tests/fixtures/dd/dd-bytes-null-trunc.spec b/tests/fixtures/dd/dd-bytes-null-trunc.spec
new file mode 100644
index 000000000..1b1cb4d44
Binary files /dev/null and b/tests/fixtures/dd/dd-bytes-null-trunc.spec differ
diff --git a/src/uu/dd/test-resources/dd-unblock-cbs16-win.spec b/tests/fixtures/dd/dd-unblock-cbs16-win.spec
similarity index 100%
rename from src/uu/dd/test-resources/dd-unblock-cbs16-win.spec
rename to tests/fixtures/dd/dd-unblock-cbs16-win.spec
diff --git a/src/uu/dd/test-resources/dd-unblock-cbs16.spec b/tests/fixtures/dd/dd-unblock-cbs16.spec
similarity index 100%
rename from src/uu/dd/test-resources/dd-unblock-cbs16.spec
rename to tests/fixtures/dd/dd-unblock-cbs16.spec
diff --git a/src/uu/dd/test-resources/dd-unblock-cbs16.test b/tests/fixtures/dd/dd-unblock-cbs16.test
similarity index 100%
rename from src/uu/dd/test-resources/dd-unblock-cbs16.test
rename to tests/fixtures/dd/dd-unblock-cbs16.test
diff --git a/src/uu/dd/test-resources/dd-unblock-cbs8-win.spec b/tests/fixtures/dd/dd-unblock-cbs8-win.spec
similarity index 100%
rename from src/uu/dd/test-resources/dd-unblock-cbs8-win.spec
rename to tests/fixtures/dd/dd-unblock-cbs8-win.spec
diff --git a/src/uu/dd/test-resources/dd-unblock-cbs8.spec b/tests/fixtures/dd/dd-unblock-cbs8.spec
similarity index 100%
rename from src/uu/dd/test-resources/dd-unblock-cbs8.spec
rename to tests/fixtures/dd/dd-unblock-cbs8.spec
diff --git a/tests/fixtures/dd/deadbeef-16.spec b/tests/fixtures/dd/deadbeef-16.spec
new file mode 100644
index 000000000..4eb7c10f1
Binary files /dev/null and b/tests/fixtures/dd/deadbeef-16.spec differ
diff --git a/tests/fixtures/dd/deadbeef-16.test b/tests/fixtures/dd/deadbeef-16.test
new file mode 100644
index 000000000..85f2b7569
--- /dev/null
+++ b/tests/fixtures/dd/deadbeef-16.test
@@ -0,0 +1 @@
+ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
\ No newline at end of file
diff --git a/src/uu/dd/test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test b/tests/fixtures/dd/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test
similarity index 100%
rename from src/uu/dd/test-resources/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test
rename to tests/fixtures/dd/deadbeef-18d99661a1de1fc9af21b0ec2cd67ba3.test
diff --git a/src/uu/dd/test-resources/gnudd-conv-sync-ibs-1031-obs-521-deadbeef.spec b/tests/fixtures/dd/gnudd-conv-sync-ibs-1031-obs-521-deadbeef.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-conv-sync-ibs-1031-obs-521-deadbeef.spec
rename to tests/fixtures/dd/gnudd-conv-sync-ibs-1031-obs-521-deadbeef.spec
diff --git a/src/uu/dd/test-resources/gnudd-conv-sync-ibs-1031-obs-521-random.spec b/tests/fixtures/dd/gnudd-conv-sync-ibs-1031-obs-521-random.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-conv-sync-ibs-1031-obs-521-random.spec
rename to tests/fixtures/dd/gnudd-conv-sync-ibs-1031-obs-521-random.spec
diff --git a/src/uu/dd/test-resources/gnudd-conv-sync-ibs-1031-obs-521-zeros.spec b/tests/fixtures/dd/gnudd-conv-sync-ibs-1031-obs-521-zeros.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-conv-sync-ibs-1031-obs-521-zeros.spec
rename to tests/fixtures/dd/gnudd-conv-sync-ibs-1031-obs-521-zeros.spec
diff --git a/src/uu/dd/test-resources/gnudd-conv-sync-ibs-521-obs-1031-deadbeef.spec b/tests/fixtures/dd/gnudd-conv-sync-ibs-521-obs-1031-deadbeef.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-conv-sync-ibs-521-obs-1031-deadbeef.spec
rename to tests/fixtures/dd/gnudd-conv-sync-ibs-521-obs-1031-deadbeef.spec
diff --git a/src/uu/dd/test-resources/gnudd-conv-sync-ibs-521-obs-1031-random.spec b/tests/fixtures/dd/gnudd-conv-sync-ibs-521-obs-1031-random.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-conv-sync-ibs-521-obs-1031-random.spec
rename to tests/fixtures/dd/gnudd-conv-sync-ibs-521-obs-1031-random.spec
diff --git a/src/uu/dd/test-resources/gnudd-conv-sync-ibs-521-obs-1031-zeros.spec b/tests/fixtures/dd/gnudd-conv-sync-ibs-521-obs-1031-zeros.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-conv-sync-ibs-521-obs-1031-zeros.spec
rename to tests/fixtures/dd/gnudd-conv-sync-ibs-521-obs-1031-zeros.spec
diff --git a/src/uu/dd/test-resources/gnudd-deadbeef-first-12345.spec b/tests/fixtures/dd/gnudd-deadbeef-first-12345.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-deadbeef-first-12345.spec
rename to tests/fixtures/dd/gnudd-deadbeef-first-12345.spec
diff --git a/src/uu/dd/test-resources/gnudd-deadbeef-first-16k.spec b/tests/fixtures/dd/gnudd-deadbeef-first-16k.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-deadbeef-first-16k.spec
rename to tests/fixtures/dd/gnudd-deadbeef-first-16k.spec
diff --git a/src/uu/dd/test-resources/gnudd-random-first-32k.spec b/tests/fixtures/dd/gnudd-random-first-32k.spec
similarity index 100%
rename from src/uu/dd/test-resources/gnudd-random-first-32k.spec
rename to tests/fixtures/dd/gnudd-random-first-32k.spec
diff --git a/src/uu/dd/test-resources/lcase-ascii.test b/tests/fixtures/dd/lcase-ascii.test
similarity index 100%
rename from src/uu/dd/test-resources/lcase-ascii.test
rename to tests/fixtures/dd/lcase-ascii.test
diff --git a/src/uu/dd/test-resources/lcase-ebcdic.spec b/tests/fixtures/dd/lcase-ebcdic.spec
similarity index 100%
rename from src/uu/dd/test-resources/lcase-ebcdic.spec
rename to tests/fixtures/dd/lcase-ebcdic.spec
diff --git a/src/uu/dd/test-resources/lcase-ebcdic.test b/tests/fixtures/dd/lcase-ebcdic.test
similarity index 100%
rename from src/uu/dd/test-resources/lcase-ebcdic.test
rename to tests/fixtures/dd/lcase-ebcdic.test
diff --git a/src/uu/dd/test-resources/lcase-ibm.spec b/tests/fixtures/dd/lcase-ibm.spec
similarity index 100%
rename from src/uu/dd/test-resources/lcase-ibm.spec
rename to tests/fixtures/dd/lcase-ibm.spec
diff --git a/src/uu/dd/test-resources/lcase-ibm.test b/tests/fixtures/dd/lcase-ibm.test
similarity index 100%
rename from src/uu/dd/test-resources/lcase-ibm.test
rename to tests/fixtures/dd/lcase-ibm.test
diff --git a/src/uu/dd/test-resources/ones-6ae59e64850377ee5470c854761551ea.test b/tests/fixtures/dd/ones-6ae59e64850377ee5470c854761551ea.test
similarity index 100%
rename from src/uu/dd/test-resources/ones-6ae59e64850377ee5470c854761551ea.test
rename to tests/fixtures/dd/ones-6ae59e64850377ee5470c854761551ea.test
diff --git a/tests/fixtures/dd/random-5828891cb1230748e146f34223bbd3b5.test b/tests/fixtures/dd/random-5828891cb1230748e146f34223bbd3b5.test
new file mode 100644
index 000000000..6e997411c
Binary files /dev/null and b/tests/fixtures/dd/random-5828891cb1230748e146f34223bbd3b5.test differ
diff --git a/src/uu/dd/test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test b/tests/fixtures/dd/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test
similarity index 100%
rename from src/uu/dd/test-resources/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test
rename to tests/fixtures/dd/seq-byte-values-b632a992d3aed5d8d1a59cc5a5a455ba.test
diff --git a/src/uu/dd/test-resources/seq-byte-values-odd.spec b/tests/fixtures/dd/seq-byte-values-odd.spec
similarity index 100%
rename from src/uu/dd/test-resources/seq-byte-values-odd.spec
rename to tests/fixtures/dd/seq-byte-values-odd.spec
diff --git a/src/uu/dd/test-resources/seq-byte-values-odd.test b/tests/fixtures/dd/seq-byte-values-odd.test
similarity index 100%
rename from src/uu/dd/test-resources/seq-byte-values-odd.test
rename to tests/fixtures/dd/seq-byte-values-odd.test
diff --git a/src/uu/dd/test-resources/seq-byte-values-swapped.test b/tests/fixtures/dd/seq-byte-values-swapped.test
similarity index 100%
rename from src/uu/dd/test-resources/seq-byte-values-swapped.test
rename to tests/fixtures/dd/seq-byte-values-swapped.test
diff --git a/src/uu/dd/test-resources/ucase-ascii.test b/tests/fixtures/dd/ucase-ascii.test
similarity index 100%
rename from src/uu/dd/test-resources/ucase-ascii.test
rename to tests/fixtures/dd/ucase-ascii.test
diff --git a/src/uu/dd/test-resources/ucase-ebcdic.spec b/tests/fixtures/dd/ucase-ebcdic.spec
similarity index 100%
rename from src/uu/dd/test-resources/ucase-ebcdic.spec
rename to tests/fixtures/dd/ucase-ebcdic.spec
diff --git a/src/uu/dd/test-resources/ucase-ebcdic.test b/tests/fixtures/dd/ucase-ebcdic.test
similarity index 100%
rename from src/uu/dd/test-resources/ucase-ebcdic.test
rename to tests/fixtures/dd/ucase-ebcdic.test
diff --git a/src/uu/dd/test-resources/ucase-ibm.spec b/tests/fixtures/dd/ucase-ibm.spec
similarity index 100%
rename from src/uu/dd/test-resources/ucase-ibm.spec
rename to tests/fixtures/dd/ucase-ibm.spec
diff --git a/src/uu/dd/test-resources/ucase-ibm.test b/tests/fixtures/dd/ucase-ibm.test
similarity index 100%
rename from src/uu/dd/test-resources/ucase-ibm.test
rename to tests/fixtures/dd/ucase-ibm.test
diff --git a/src/uu/dd/test-resources/zeros-620f0b67a91f7f74151bc5be745b7110.test b/tests/fixtures/dd/zeros-620f0b67a91f7f74151bc5be745b7110.test
similarity index 100%
rename from src/uu/dd/test-resources/zeros-620f0b67a91f7f74151bc5be745b7110.test
rename to tests/fixtures/dd/zeros-620f0b67a91f7f74151bc5be745b7110.test
diff --git a/tests/fixtures/hashsum/b3sum.checkfile b/tests/fixtures/hashsum/b3sum.checkfile
new file mode 100644
index 000000000..f8d34d0b6
--- /dev/null
+++ b/tests/fixtures/hashsum/b3sum.checkfile
@@ -0,0 +1 @@
+a1a55887535397bf461902491c8779188a5dd1f8c3951b3d9cf6ecba194e87b0  input.txt
diff --git a/tests/fixtures/hashsum/b3sum.expected b/tests/fixtures/hashsum/b3sum.expected
new file mode 100644
index 000000000..a56e54432
--- /dev/null
+++ b/tests/fixtures/hashsum/b3sum.expected
@@ -0,0 +1 @@
+a1a55887535397bf461902491c8779188a5dd1f8c3951b3d9cf6ecba194e87b0
\ No newline at end of file
diff --git a/tests/fixtures/join/fields_5.txt b/tests/fixtures/join/fields_5.txt
new file mode 100644
index 000000000..13b9b0736
--- /dev/null
+++ b/tests/fixtures/join/fields_5.txt
@@ -0,0 +1,6 @@
+1
+2
+5
+3
+6
+4
diff --git a/tests/fixtures/join/non-line_feeds.expected b/tests/fixtures/join/non-line_feeds.expected
new file mode 100644
index 000000000..c4cb5b448
--- /dev/null
+++ b/tests/fixtures/join/non-line_feeds.expected
@@ -0,0 +1,2 @@
+ b
 d
+a c f
diff --git a/tests/fixtures/join/non-line_feeds_1.txt b/tests/fixtures/join/non-line_feeds_1.txt
new file mode 100644
index 000000000..f3e0c0732
--- /dev/null
+++ b/tests/fixtures/join/non-line_feeds_1.txt
@@ -0,0 +1,2 @@
+ b
+a c
diff --git a/tests/fixtures/join/non-line_feeds_2.txt b/tests/fixtures/join/non-line_feeds_2.txt
new file mode 100644
index 000000000..0a5301e13
--- /dev/null
+++ b/tests/fixtures/join/non-line_feeds_2.txt
@@ -0,0 +1,2 @@
+ d
+a f
diff --git a/tests/fixtures/join/non-unicode.expected b/tests/fixtures/join/non-unicode.expected
new file mode 100644
index 000000000..7c2e0d9af
Binary files /dev/null and b/tests/fixtures/join/non-unicode.expected differ
diff --git a/tests/fixtures/join/non-unicode_1.bin b/tests/fixtures/join/non-unicode_1.bin
new file mode 100644
index 000000000..e264bd505
Binary files /dev/null and b/tests/fixtures/join/non-unicode_1.bin differ
diff --git a/tests/fixtures/join/non-unicode_2.bin b/tests/fixtures/join/non-unicode_2.bin
new file mode 100644
index 000000000..6b336c669
Binary files /dev/null and b/tests/fixtures/join/non-unicode_2.bin differ
diff --git a/tests/fixtures/join/non-unicode_sep.expected b/tests/fixtures/join/non-unicode_sep.expected
new file mode 100644
index 000000000..c4041409b
Binary files /dev/null and b/tests/fixtures/join/non-unicode_sep.expected differ
diff --git a/tests/fixtures/join/null-sep.expected b/tests/fixtures/join/null-sep.expected
new file mode 100644
index 000000000..7d91c5782
Binary files /dev/null and b/tests/fixtures/join/null-sep.expected differ
diff --git a/tests/fixtures/join/out_of_bounds_fields.expected b/tests/fixtures/join/out_of_bounds_fields.expected
new file mode 100644
index 000000000..98b0f84fe
--- /dev/null
+++ b/tests/fixtures/join/out_of_bounds_fields.expected
@@ -0,0 +1,25 @@
+ 1 2 c 1 cd
+ 1 3 d 2 de
+ 1 5 e 3 ef
+ 1 7 f 4 fg
+ 1 11 g 5 gh
+ 2 2 c 1 cd
+ 2 3 d 2 de
+ 2 5 e 3 ef
+ 2 7 f 4 fg
+ 2 11 g 5 gh
+ 3 2 c 1 cd
+ 3 3 d 2 de
+ 3 5 e 3 ef
+ 3 7 f 4 fg
+ 3 11 g 5 gh
+ 5 2 c 1 cd
+ 5 3 d 2 de
+ 5 5 e 3 ef
+ 5 7 f 4 fg
+ 5 11 g 5 gh
+ 8 2 c 1 cd
+ 8 3 d 2 de
+ 8 5 e 3 ef
+ 8 7 f 4 fg
+ 8 11 g 5 gh
diff --git a/tests/fixtures/join/z.expected b/tests/fixtures/join/z.expected
new file mode 100644
index 000000000..ed85bb053
Binary files /dev/null and b/tests/fixtures/join/z.expected differ
diff --git a/tests/fixtures/split/asciilowercase.txt b/tests/fixtures/split/asciilowercase.txt
new file mode 100644
index 000000000..b0883f382
--- /dev/null
+++ b/tests/fixtures/split/asciilowercase.txt
@@ -0,0 +1 @@
+abcdefghijklmnopqrstuvwxyz
diff --git a/tests/fixtures/split/fivelines.txt b/tests/fixtures/split/fivelines.txt
new file mode 100644
index 000000000..8a1218a10
--- /dev/null
+++ b/tests/fixtures/split/fivelines.txt
@@ -0,0 +1,5 @@
+1
+2
+3
+4
+5
diff --git a/tests/fixtures/split/letters.txt b/tests/fixtures/split/letters.txt
new file mode 100644
index 000000000..03e1003e3
--- /dev/null
+++ b/tests/fixtures/split/letters.txt
@@ -0,0 +1,5 @@
+aaaaaaaaa
+bbbb
+cccc
+dd
+ee
diff --git a/tests/fixtures/split/ninetyonebytes.txt b/tests/fixtures/split/ninetyonebytes.txt
new file mode 100644
index 000000000..62049a6b3
--- /dev/null
+++ b/tests/fixtures/split/ninetyonebytes.txt
@@ -0,0 +1 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
\ No newline at end of file
diff --git a/tests/fixtures/split/onehundredlines.txt b/tests/fixtures/split/onehundredlines.txt
new file mode 100644
index 000000000..f2abdb403
--- /dev/null
+++ b/tests/fixtures/split/onehundredlines.txt
@@ -0,0 +1,100 @@
+00
+01
+02
+03
+04
+05
+06
+07
+08
+09
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
diff --git a/tests/fixtures/split/sixhundredfiftyonebytes.txt b/tests/fixtures/split/sixhundredfiftyonebytes.txt
new file mode 100644
index 000000000..f16b32e85
--- /dev/null
+++ b/tests/fixtures/split/sixhundredfiftyonebytes.txt
@@ -0,0 +1 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
\ No newline at end of file
diff --git a/tests/fixtures/split/threebytes.txt b/tests/fixtures/split/threebytes.txt
new file mode 100644
index 000000000..f2ba8f84a
--- /dev/null
+++ b/tests/fixtures/split/threebytes.txt
@@ -0,0 +1 @@
+abc
\ No newline at end of file
diff --git a/tests/fixtures/split/twohundredfortyonebytes.txt b/tests/fixtures/split/twohundredfortyonebytes.txt
new file mode 100644
index 000000000..10a53a61c
--- /dev/null
+++ b/tests/fixtures/split/twohundredfortyonebytes.txt
@@ -0,0 +1 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
\ No newline at end of file
diff --git a/tests/fixtures/wc/files0_list.txt b/tests/fixtures/wc/files0_list.txt
new file mode 100644
index 000000000..5c7af28f0
Binary files /dev/null and b/tests/fixtures/wc/files0_list.txt differ
diff --git a/tests/fixtures/wc/files0_list_with_stdin.txt b/tests/fixtures/wc/files0_list_with_stdin.txt
new file mode 100644
index 000000000..b938a7867
Binary files /dev/null and b/tests/fixtures/wc/files0_list_with_stdin.txt differ
diff --git a/util/GHA-delete-GNU-workflow-logs.sh b/util/GHA-delete-GNU-workflow-logs.sh
index 19e3311d4..ebeb7cfe8 100755
--- a/util/GHA-delete-GNU-workflow-logs.sh
+++ b/util/GHA-delete-GNU-workflow-logs.sh
@@ -2,10 +2,10 @@
 
 # spell-checker:ignore (utils) gitsome jq ; (gh) repos
 
-ME="${0}"
-ME_dir="$(dirname -- "${ME}")"
-ME_parent_dir="$(dirname -- "${ME_dir}")"
-ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}")"
+# ME="${0}"
+# ME_dir="$(dirname -- "${ME}")"
+# ME_parent_dir="$(dirname -- "${ME_dir}")"
+# ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}")"
 
 # ref: <https://stackoverflow.com/questions/57927115/anyone-know-a-way-to-delete-a-workflow-from-github-actions>
 
@@ -15,30 +15,35 @@ ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}")"
 
 # * `gh` available?
 unset GH
-gh --version 1>/dev/null 2>&1
-if [ $? -eq 0 ]; then export GH="gh"; fi
+if gh --version 1>/dev/null 2>&1; then
+    export GH="gh"
+else
+    echo "ERR!: missing \`gh\` (see install instructions at <https://github.com/cli/cli>)" 1>&2
+fi
 
 # * `jq` available?
 unset JQ
-jq --version 1>/dev/null 2>&1
-if [ $? -eq 0 ]; then export JQ="jq"; fi
+if jq --version 1>/dev/null 2>&1; then
+    export JQ="jq"
+else
+    echo "ERR!: missing \`jq\` (install with \`sudo apt install jq\`)" 1>&2
+fi
 
 if [ -z "${GH}" ] || [ -z "${JQ}" ]; then
-    if [ -z "${GH}" ]; then
-        echo 'ERR!: missing `gh` (see install instructions at <https://github.com/cli/cli>)' 1>&2
-    fi
-    if [ -z "${JQ}" ]; then
-        echo 'ERR!: missing `jq` (install with `sudo apt install jq`)' 1>&2
-    fi
     exit 1
 fi
 
-dry_run=true
+case "${dry_run}" in
+    '0' | 'f' | 'false' | 'no' | 'never' | 'none') unset dry_run ;;
+    *) dry_run="true" ;;
+esac
 
-USER_NAME=uutils
-REPO_NAME=coreutils
-WORK_NAME=GNU
+USER_NAME="${USER_NAME:-uutils}"
+REPO_NAME="${REPO_NAME:-coreutils}"
+WORK_NAME="${WORK_NAME:-GNU}"
 
 # * `--paginate` retrieves all pages
 # gh api --paginate "repos/${USER_NAME}/${REPO_NAME}/actions/runs" | jq -r ".workflow_runs[] | select(.name == \"${WORK_NAME}\") | (.id)" | xargs -n1 sh -c "for arg do { echo gh api repos/${USER_NAME}/${REPO_NAME}/actions/runs/\${arg} -X DELETE ; if [ -z "$dry_run" ]; then gh api repos/${USER_NAME}/${REPO_NAME}/actions/runs/\${arg} -X DELETE ; fi ; } ; done ;" _
-gh api "repos/${USER_NAME}/${REPO_NAME}/actions/runs" | jq -r ".workflow_runs[] | select(.name == \"${WORK_NAME}\") | (.id)" | xargs -n1 sh -c "for arg do { echo gh api repos/${USER_NAME}/${REPO_NAME}/actions/runs/\${arg} -X DELETE ; if [ -z "$dry_run" ]; then gh api repos/${USER_NAME}/${REPO_NAME}/actions/runs/\${arg} -X DELETE ; fi ; } ; done ;" _
+gh api "repos/${USER_NAME}/${REPO_NAME}/actions/runs" |
+    jq -r ".workflow_runs[] | select(.name == \"${WORK_NAME}\") | (.id)" |
+    xargs -n1 sh -c "for arg do { echo gh api repos/${USER_NAME}/${REPO_NAME}/actions/runs/\${arg} -X DELETE ; if [ -z \"${dry_run}\" ]; then gh api repos/${USER_NAME}/${REPO_NAME}/actions/runs/\${arg} -X DELETE ; fi ; } ; done ;" _
diff --git a/util/build-code_coverage.sh b/util/build-code_coverage.sh
index 7ad3165fe..4082bc13d 100755
--- a/util/build-code_coverage.sh
+++ b/util/build-code_coverage.sh
@@ -4,16 +4,18 @@
 # 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 uutils
+# spell-checker:ignore (utils) genhtml grcov lcov readlink sccache shellcheck uutils
 
 FEATURES_OPTION="--features feat_os_unix"
 
-ME_dir="$(dirname -- $(readlink -fm -- "$0"))"
+ME="${0}"
+ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
-cd "${REPO_main_dir}"
-echo "[ \"$PWD\" ]"
+cd "${REPO_main_dir}" &&
+    echo "[ \"$PWD\" ]"
 
+#shellcheck disable=SC2086
 UTIL_LIST=$("${ME_dir}"/show-utils.sh ${FEATURES_OPTION})
 CARGO_INDIVIDUAL_PACKAGE_OPTIONS=""
 for UTIL in ${UTIL_LIST}; do
@@ -25,15 +27,18 @@ done
 # cargo clean
 
 export CARGO_INCREMENTAL=0
-export RUSTC_WRAPPER=""     ## NOTE: RUSTC_WRAPPER=='sccache' breaks code coverage calculations (uu_*.gcno files are not created during build)
+export RUSTC_WRAPPER="" ## NOTE: RUSTC_WRAPPER=='sccache' breaks code coverage calculations (uu_*.gcno files are not created during build)
 # export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads"
 export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
 export RUSTDOCFLAGS="-Cpanic=abort"
 export RUSTUP_TOOLCHAIN="nightly-gnu"
-cargo build ${FEATURES_OPTION}
-cargo test --no-run ${FEATURES_OPTION}
-cargo test --quiet ${FEATURES_OPTION}
-cargo test --quiet ${FEATURES_OPTION} ${CARGO_INDIVIDUAL_PACKAGE_OPTIONS}
+#shellcheck disable=SC2086
+{
+    cargo build ${FEATURES_OPTION}
+    cargo test --no-run ${FEATURES_OPTION}
+    cargo test --quiet ${FEATURES_OPTION}
+    cargo test --quiet ${FEATURES_OPTION} ${CARGO_INDIVIDUAL_PACKAGE_OPTIONS}
+}
 
 export COVERAGE_REPORT_DIR
 if [ -z "${COVERAGE_REPORT_DIR}" ]; then COVERAGE_REPORT_DIR="${REPO_main_dir}/target/debug/coverage-nix"; fi
@@ -47,10 +52,10 @@ mkdir -p "${COVERAGE_REPORT_DIR}"
 grcov . --output-type lcov --output-path "${COVERAGE_REPORT_DIR}/../lcov.info" --branch --ignore build.rs --ignore '/*' --ignore '[A-Za-z]:/*' --ignore 'C:/Users/*' --excl-br-line '^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()'
 # * build HTML
 # -- use `genhtml` if available for display of additional branch coverage information
-genhtml --version 2>/dev/null 1>&2
-if [ $? -eq 0 ]; then
+if genhtml --version 2>/dev/null 1>&2; then
     genhtml "${COVERAGE_REPORT_DIR}/../lcov.info" --output-directory "${COVERAGE_REPORT_DIR}" --branch-coverage --function-coverage | grep ": [0-9]"
 else
     grcov . --output-type html --output-path "${COVERAGE_REPORT_DIR}" --branch --ignore build.rs --ignore '/*' --ignore '[A-Za-z]:/*' --ignore 'C:/Users/*' --excl-br-line '^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()'
 fi
-if [ $? -ne 0 ]; then exit 1 ; fi
+# shellcheck disable=SC2181
+if [ $? -ne 0 ]; then exit 1; fi
diff --git a/util/build-gnu.sh b/util/build-gnu.sh
index eb8293fbe..924d14d25 100755
--- a/util/build-gnu.sh
+++ b/util/build-gnu.sh
@@ -1,66 +1,111 @@
 #!/bin/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 'debug'
 
-# spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall gnulib inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW baddecode ; (vars/env) BUILDDIR SRCDIR
+# 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
 
 set -e
-if test ! -d ../gnu; then
-    echo "Could not find ../gnu"
-    echo "git clone https://github.com:coreutils/coreutils.git gnu"
-    exit 1
-fi
-if test ! -d ../gnulib; then
-    echo "Could not find ../gnulib"
-    echo "git clone https://github.com/coreutils/gnulib.git gnulib"
+
+ME="${0}"
+ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+REPO_main_dir="$(dirname -- "${ME_dir}")"
+
+echo "ME='${ME}'"
+echo "ME_dir='${ME_dir}'"
+echo "REPO_main_dir='${REPO_main_dir}'"
+
+### * 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}")"
+
+echo "path_UUTILS='${path_UUTILS}'"
+echo "path_GNU='${path_GNU}'"
+
+###
+
+if test ! -d "${path_GNU}"; then
+    echo "Could not find GNU (expected at '${path_GNU}')"
+    echo "git clone --recurse-submodules https://github.com/coreutils/coreutils.git \"${path_GNU}\""
     exit 1
 fi
 
+###
 
-pushd $(pwd)
-make PROFILE=release
-BUILDDIR="$PWD/target/release/"
-cp "${BUILDDIR}/install" "${BUILDDIR}/ginstall" # The GNU tests rename this script before running, to avoid confusion with the make target
+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}'"
+
+cd "${path_UUTILS}" && echo "[ pwd:'${PWD}' ]"
+SELINUX_ENABLED=1 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
-for sum in b2sum md5sum sha1sum sha224sum sha256sum sha384sum sha512sum
-do
-    sum_path="${BUILDDIR}/${sum}"
-    test -f "${sum_path}" || cp "${BUILDDIR}/hashsum" "${sum_path}"
+for sum in b2sum b3sum md5sum sha1sum sha224sum sha256sum sha384sum sha512sum; do
+    sum_path="${UU_BUILD_DIR}/${sum}"
+    test -f "${sum_path}" || cp "${UU_BUILD_DIR}/hashsum" "${sum_path}"
 done
-test -f "${BUILDDIR}/[" || cp "${BUILDDIR}/test" "${BUILDDIR}/["
-popd
-GNULIB_SRCDIR="$PWD/../gnulib"
-pushd ../gnu/
+test -f "${UU_BUILD_DIR}/[" || cp "${UU_BUILD_DIR}/test" "${UU_BUILD_DIR}/["
+
+##
+
+cd "${path_GNU}" && echo "[ pwd:'${PWD}' ]"
 
 # Any binaries that aren't built become `false` so their tests fail
-for binary in $(./build-aux/gen-lists-of-programs.sh --list-progs)
-do
-    bin_path="${BUILDDIR}/${binary}"
-    test -f "${bin_path}" || { echo "'${binary}' was not built with uutils, using the 'false' program"; cp "${BUILDDIR}/false" "${bin_path}"; }
+for binary in $(./build-aux/gen-lists-of-programs.sh --list-progs); do
+    bin_path="${UU_BUILD_DIR}/${binary}"
+    test -f "${bin_path}" || {
+        echo "'${binary}' was not built with uutils, using the 'false' program"
+        cp "${UU_BUILD_DIR}/false" "${bin_path}"
+    }
 done
 
-./bootstrap --gnulib-srcdir="$GNULIB_SRCDIR"
+./bootstrap
 ./configure --quiet --disable-gcc-warnings
 #Add timeout to to protect against hangs
-sed -i 's|"\$@|/usr/bin/timeout 600 "\$@|' build-aux/test-driver
+sed -i 's|^"\$@|/usr/bin/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='${BUILDDIR//\//\\/}\$(PATH_SEPARATOR)'\"\$\$PATH\" \\\/" Makefile
+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)"
-# Generate the factor tests, so they can be fixed
-# Used to be 36. Reduced to 20 to decrease the log size
-for i in {00..20}
-do
-    make tests/factor/t${i}.sh
-done
-
-# strip the long stuff
-for i in {21..36}
-do
+# Handle generated factor tests
+t_first=00
+t_max=36
+# t_max_release=20
+# if test "${UU_MAKE_PROFILE}" != "debug"; then
+#     # Generate the factor tests, so they can be fixed
+#     # * reduced to 20 to decrease log size (down from 36 expected by GNU)
+#     # * only for 'release', skipped for 'debug' as redundant and too time consuming (causing timeout errors)
+#     seq=$(
+#         i=${t_first}
+#         while test "${i}" -le "${t_max_release}"; do
+#             printf '%02d ' $i
+#             i=$((i + 1))
+#         done
+#     )
+#     for i in ${seq}; do
+#         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
+#     t_first=$((t_max_release + 1))
+# fi
+# strip all (debug) or just the longer (release) factor tests from Makefile
+seq=$(
+    i=${t_first}
+    while test "${i}" -le "${t_max}"; do
+        printf '%02d ' ${i}
+        i=$((i + 1))
+    done
+)
+for i in ${seq}; do
+    echo "strip t${i}.sh from Makefile"
     sed -i -e "s/\$(tf)\/t${i}.sh//g" Makefile
 done
 
-
 grep -rl 'path_prepend_' tests/* | xargs sed -i 's| path_prepend_ ./src||'
-sed -i -e 's|^seq |/usr/bin/seq |' -e 's|sha1sum |/usr/bin/sha1sum |' tests/factor/t*sh
 
 # Remove tests checking for --version & --help
 # Not really interesting for us and logs are too big
@@ -77,30 +122,22 @@ sed -i -e '/tests\/misc\/seq-precision.sh/ D' \
 sed -i '/INT_OFLOW/ D' tests/misc/printf.sh
 
 # Use the system coreutils where the test fails due to error in a util that is not the one being tested
-sed -i 's|stat|/usr/bin/stat|' tests/chgrp/basic.sh tests/cp/existing-perm-dir.sh tests/touch/60-seconds.sh tests/misc/sort-compress-proc.sh
-sed -i 's|ls -|/usr/bin/ls -|' tests/chgrp/posix-H.sh tests/chown/deref.sh tests/cp/same-file.sh tests/misc/mknod.sh tests/mv/part-symlink.sh tests/du/8gb.sh
-sed -i 's|mkdir |/usr/bin/mkdir |' tests/cp/existing-perm-dir.sh tests/rm/empty-inacc.sh
-sed -i 's|timeout \([[:digit:]]\)| /usr/bin/timeout \1|' tests/tail-2/inotify-rotate.sh tests/tail-2/inotify-dir-recreate.sh tests/tail-2/inotify-rotate-resources.sh tests/cp/parent-perm-race.sh tests/ls/infloop.sh tests/misc/sort-exit-early.sh tests/misc/sort-NaN-infloop.sh tests/misc/uniq-perf.sh tests/tail-2/inotify-only-regular.sh tests/tail-2/pipe-f2.sh tests/tail-2/retry.sh tests/tail-2/symlink.sh tests/tail-2/wait.sh tests/tail-2/pid.sh tests/dd/stats.sh tests/tail-2/follow-name.sh tests/misc/shuf.sh # Don't break the function called 'grep_timeout'
-sed -i 's|chmod |/usr/bin/chmod |' tests/du/inacc-dir.sh tests/mkdir/p-3.sh tests/tail-2/tail-n0f.sh tests/cp/fail-perm.sh tests/du/inaccessible-cwd.sh tests/mv/i-2.sh tests/chgrp/basic.sh tests/misc/shuf.sh
+sed -i 's|stat|/usr/bin/stat|' tests/touch/60-seconds.sh tests/misc/sort-compress-proc.sh
+sed -i 's|ls -|/usr/bin/ls -|' tests/cp/same-file.sh tests/misc/mknod.sh tests/mv/part-symlink.sh
+sed -i 's|chmod |/usr/bin/chmod |' tests/du/inacc-dir.sh tests/tail-2/tail-n0f.sh tests/cp/fail-perm.sh tests/mv/i-2.sh tests/misc/shuf.sh
 sed -i 's|sort |/usr/bin/sort |' tests/ls/hyperlink.sh tests/misc/test-N.sh
 sed -i 's|split |/usr/bin/split |' tests/misc/factor-parallel.sh
-sed -i 's|truncate |/usr/bin/truncate |' tests/split/fail.sh
-sed -i 's|dd |/usr/bin/dd |' tests/du/8gb.sh tests/tail-2/big-4gb.sh init.cfg
 sed -i 's|id -|/usr/bin/id -|' tests/misc/runcon-no-reorder.sh
-sed -i 's|touch |/usr/bin/touch |' tests/cp/preserve-link.sh tests/cp/reflink-perm.sh tests/ls/block-size.sh tests/ls/abmon-align.sh tests/ls/rt-1.sh tests/mv/update.sh tests/misc/ls-time.sh tests/misc/stat-nanoseconds.sh tests/misc/time-style.sh tests/misc/test-N.sh
+sed -i 's|touch |/usr/bin/touch |' tests/cp/preserve-link.sh tests/cp/reflink-perm.sh tests/ls/block-size.sh tests/mv/update.sh tests/misc/ls-time.sh tests/misc/stat-nanoseconds.sh tests/misc/time-style.sh tests/misc/test-N.sh
 sed -i 's|ln -|/usr/bin/ln -|' tests/cp/link-deref.sh
-sed -i 's|printf |/usr/bin/printf |' tests/dd/ascii.sh
 sed -i 's|cp |/usr/bin/cp |' tests/mv/hard-2.sh
 sed -i 's|paste |/usr/bin/paste |' tests/misc/od-endian.sh
-sed -i 's|seq |/usr/bin/seq |' tests/misc/sort-discrim.sh
 
 # Add specific timeout to tests that currently hang to limit time spent waiting
-sed -i 's|seq \$|/usr/bin/timeout 0.1 seq \$|' tests/misc/seq-precision.sh tests/misc/seq-long-double.sh
-
+sed -i 's|\(^\s*\)seq \$|\1/usr/bin/timeout 0.1 seq \$|' tests/misc/seq-precision.sh tests/misc/seq-long-double.sh
 
 # Remove dup of /usr/bin/ when executed several times
-grep -rl '/usr/bin//usr/bin/' tests/* | xargs --no-run-if-empty sed -i 's|/usr/bin//usr/bin/|/usr/bin/|g'
-
+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'
 
 #### Adjust tests to make them work with Rust/coreutils
 # in some cases, what we are doing in rust/coreutils is good (or better)
@@ -117,7 +154,7 @@ sed -i -e "s|rm: cannot remove 'a/1'|rm: cannot remove 'a'|g" tests/rm/rm2.sh
 
 sed -i -e "s|removed directory 'a/'|removed directory 'a'|g" tests/rm/v-slash.sh
 
-test -f "${BUILDDIR}/getlimits" || cp src/getlimits "${BUILDDIR}"
+test -f "${UU_BUILD_DIR}/getlimits" || cp src/getlimits "${UU_BUILD_DIR}"
 
 # When decoding an invalid base32/64 string, gnu writes everything it was able to decode until
 # it hit the decode error, while we don't write anything if the input is invalid.
@@ -133,3 +170,14 @@ sed -i "s/  {ERR_SUBST=>\"s\/(unrecognized|unknown) option \[-' \]\*foobar\[' \]
 
 # Remove the check whether a util was built. Otherwise tests against utils like "arch" are not run.
 sed -i "s|require_built_ |# require_built_ |g" init.cfg
+
+# with the option -/ is used, clap is returning a better error than GNU's. Adjust the GNU test
+sed -i -e "s~  grep \" '\*/'\*\" err || framework_failure_~  grep \" '*-/'*\" err || framework_failure_~" tests/misc/usage_vs_getopt.sh
+sed -i -e "s~  sed -n \"1s/'\\\/'/'OPT'/p\" < err >> pat || framework_failure_~  sed -n \"1s/'-\\\/'/'OPT'/p\" < err >> pat || framework_failure_~" tests/misc/usage_vs_getopt.sh
+# Ignore some binaries (not built)
+# And change the default error code to 2
+# see issue #3331
+sed -i -e "s/rcexp=1$/rcexp=2\n  case \"\$prg\" in chcon|dir|runcon|vdir) return;; esac/" tests/misc/usage_vs_getopt.sh
+
+# Update the GNU error message to match ours
+sed -i -e "s/ln: 'f' and 'f' are the same file/ln: failed to link 'f' to 'f': Same file/g" tests/ln/hard-backup.sh
diff --git a/util/compare_gnu_result.py b/util/compare_gnu_result.py
index 52aa96abe..9501f4f5f 100755
--- a/util/compare_gnu_result.py
+++ b/util/compare_gnu_result.py
@@ -1,7 +1,7 @@
 #! /usr/bin/python
 
 """
-Compare the current results to the last results gathered from the master branch to highlight
+Compare the current results to the last results gathered from the main branch to highlight
 if a PR is making the results better/worse
 """
 
@@ -9,8 +9,10 @@ import json
 import sys
 from os import environ
 
+REPO_DEFAULT_BRANCH = environ.get('REPO_DEFAULT_BRANCH', 'main')
+
 NEW = json.load(open("gnu-result.json"))
-OLD = json.load(open("master-gnu-result.json"))
+OLD = json.load(open("main-gnu-result.json"))
 
 # Extract the specific results from the dicts
 last = OLD[list(OLD.keys())[0]]
@@ -24,9 +26,12 @@ skip_d = int(current["skip"]) - int(last["skip"])
 
 # Get an annotation to highlight changes
 print(
-    f"::warning ::Changes from master: PASS {pass_d:+d} / FAIL {fail_d:+d} / ERROR {error_d:+d} / SKIP {skip_d:+d} "
+    f"::warning ::Changes from '{REPO_DEFAULT_BRANCH}': PASS {pass_d:+d} / FAIL {fail_d:+d} / ERROR {error_d:+d} / SKIP {skip_d:+d} "
 )
 
 # If results are worse fail the job to draw attention
 if pass_d < 0:
+    print(
+        f"::error ::PASS count is reduced from '{REPO_DEFAULT_BRANCH}': PASS {pass_d:+d} "
+    )
     sys.exit(1)
diff --git a/util/dwr.sh b/util/dwr.sh
new file mode 100644
index 000000000..ff1f81170
--- /dev/null
+++ b/util/dwr.sh
@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+
+# `dwr` - delete workflow runs (by DJ Adams)
+# ref: <https://github.com/qmacro/dotfiles/blob/230c6df494f239e9d1762794943847816e1b7c32/scripts/dwr>
+# ref: [Mass deletion of GitHub Actions workflow runs](https://qmacro.org/autodidactics/2021/03/26/mass-deletion-of-github-actions-workflow-runs) @@ <https://archive.is/rxdCY>
+
+# LICENSE: "Feel free to steal, modify, or make fun of" (from <https://github.com/qmacro/dotfiles/blob/230c6df494f239e9d1762794943847816e1b7c32/README.md>)
+
+# spell-checker:ignore (options) multi ; (people) DJ Adams * qmacro ; (words) gsub
+
+# Given an "owner/repo" name, such as "qmacro/thinking-aloud",
+# retrieve the workflow runs for that repo and present them in a
+# list. Selected runs will be deleted. Uses the GitHub API.
+
+# Requires gh (GitHub CLI) and jq (JSON processor)
+
+# First version
+
+set -o errexit
+set -o pipefail
+
+declare repo=${1:?No owner/repo specified}
+
+jq_script() {
+
+    cat <<EOF
+    def symbol:
+        sub("skipped"; "SKIP") |
+        sub("success"; "GOOD") |
+        sub("failure"; "FAIL");
+
+    def tz:
+        gsub("[TZ]"; " ");
+
+
+    .workflow_runs[]
+        | [
+            (.conclusion | symbol),
+            (.created_at | tz),
+            .id,
+            .event,
+            .name
+        ]
+        | @tsv
+EOF
+
+}
+
+select_runs() {
+
+    gh api --paginate "/repos/$repo/actions/runs" |
+        jq -r -f <(jq_script) |
+        fzf --multi
+
+}
+
+delete_run() {
+
+    local run id result
+    run=$1
+    id="$(cut -f 3 <<<"$run")"
+    gh api -X DELETE "/repos/$repo/actions/runs/$id"
+    # shellcheck disable=SC2181
+    [[ $? = 0 ]] && result="OK!" || result="BAD"
+    printf "%s\t%s\n" "$result" "$run"
+
+}
+
+delete_runs() {
+
+    local id
+    while read -r run; do
+        delete_run "$run"
+        sleep 0.25
+    done
+
+}
+
+main() {
+
+    select_runs | delete_runs
+
+}
+
+main
diff --git a/util/gnu-json-result.py b/util/gnu-json-result.py
new file mode 100644
index 000000000..a51aa7d94
--- /dev/null
+++ b/util/gnu-json-result.py
@@ -0,0 +1,27 @@
+"""
+Extract the GNU logs into a JSON file.
+"""
+
+import json
+from pathlib import Path
+import sys
+from os import environ
+
+out = {}
+
+test_dir = Path(sys.argv[1])
+for filepath in test_dir.glob("**/*.log"):
+    path = Path(filepath)
+    current = out
+    for key in path.parent.relative_to(test_dir).parts:
+        if key not in current:
+            current[key] = {}
+        current = current[key]
+    try:
+        with open(path) as f:
+            content = f.read()
+            current[path.name] = content.split("\n")[-2].split(" ")[0]
+    except:
+        pass
+
+print(json.dumps(out, indent=2, sort_keys=True))
\ No newline at end of file
diff --git a/util/publish.sh b/util/publish.sh
index ae171e39c..edd9779ef 100755
--- a/util/publish.sh
+++ b/util/publish.sh
@@ -1,31 +1,28 @@
-#!/bin/bash
+#!/bin/sh
 set -e
 
 ARG=""
 if test "$1" != "--do-it"; then
-   ARG="--dry-run --allow-dirty"
+    ARG="--dry-run --allow-dirty"
 fi
 
-cd src/uucore/
-cargo publish $ARG
-cd -
-sleep 2s
-
-cd src/uucore_procs/
-cargo publish $ARG
-cd -
-sleep 2s
-
-cd src/uu/stdbuf/src/libstdbuf/
-cargo publish $ARG
-cd -
-sleep 2s
+for dir in src/uucore/ src/uucore_procs/ src/uu/stdbuf/src/libstdbuf/; do
+    (
+        cd "$dir"
+        #shellcheck disable=SC2086
+        cargo publish $ARG
+    )
+    sleep 2s
+done
 
 PROGS=$(ls -1d src/uu/*/)
 for p in $PROGS; do
-    cd $p
-    cargo publish $ARG
-    cd -
+    (
+        cd "$p"
+        #shellcheck disable=SC2086
+        cargo publish $ARG
+    )
 done
 
+#shellcheck disable=SC2086
 cargo publish $ARG
diff --git a/util/remaining-gnu-error.py b/util/remaining-gnu-error.py
new file mode 100755
index 000000000..5be7e784c
--- /dev/null
+++ b/util/remaining-gnu-error.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# This script lists the GNU failing tests by size
+# Just like with util/run-gnu-test.sh, we expect the gnu sources
+# to be in ../
+import urllib.request
+
+import urllib
+import os
+import glob
+import json
+
+base = "../gnu/tests/"
+urllib.request.urlretrieve(
+    "https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json",
+    "result.json",
+)
+
+tests = glob.glob(base + "/*/*.sh")
+tests_pl = glob.glob(base + "/*/*.pl")
+tests_xpl = glob.glob(base + "/*/*.xpl")
+tests = tests + tests_pl + tests_xpl
+
+# sort by size
+list_of_files = sorted(tests, key=lambda x: os.stat(x).st_size)
+
+with open("result.json", "r") as json_file:
+    data = json.load(json_file)
+
+for d in data:
+    for e in data[d]:
+        # Not all the tests are .sh files, rename them if not.
+        script = e.replace(".log", ".sh")
+        a = f"{base}{d}{script}"
+        if not os.path.exists(a):
+            a = a.replace(".sh", ".pl")
+            if not os.path.exists(a):
+                a = a.replace(".pl", ".xpl")
+
+        # the tests pass, we don't care anymore
+        if data[d][e] == "PASS":
+            list_of_files.remove(a)
+
+# Remove the factor tests and reverse the list (bigger first)
+tests = list(filter(lambda k: "factor" not in k, list_of_files))
+
+for f in reversed(tests):
+    print("%s: %s" % (f, os.stat(f).st_size))
+print("")
+print("%s tests remaining" % len(tests))
diff --git a/util/run-gnu-test.sh b/util/run-gnu-test.sh
index 483fc1be9..9b784699c 100755
--- a/util/run-gnu-test.sh
+++ b/util/run-gnu-test.sh
@@ -1,10 +1,33 @@
-#!/bin/bash
-# spell-checker:ignore (env/vars) BUILDDIR GNULIB SUBDIRS
-cd "$(dirname "${BASH_SOURCE[0]}")/../.."
+#!/bin/sh
+# `run-gnu-test.bash [TEST]`
+# run GNU test (or all tests if TEST is missing/null)
+#
+# UU_MAKE_PROFILE == 'debug' | 'release' ## build profile used for *uutils* build; may be supplied by caller, defaults to 'release'
+
+# spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS ; (utils) shellcheck
+
+# 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")")"
+REPO_main_dir="$(dirname -- "${ME_dir}")"
+
+echo "ME_dir='${ME_dir}'"
+echo "REPO_main_dir='${REPO_main_dir}'"
+
 set -e
-BUILDDIR="${PWD}/uutils/target/release"
-GNULIB_DIR="${PWD}/gnulib"
-pushd gnu
+
+### * 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}")"
+
+echo "path_UUTILS='${path_UUTILS}'"
+echo "path_GNU='${path_GNU}'"
+
+###
+
+cd "${path_GNU}" && echo "[ pwd:'${PWD}' ]"
 
 export RUST_BACKTRACE=1
 
@@ -13,4 +36,12 @@ if test -n "$1"; then
     export RUN_TEST="TESTS=$1"
 fi
 
-timeout -sKILL 2h make -j "$(nproc)" check $RUN_TEST SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no || : # Kill after 4 hours in case something gets stuck in make
+# * timeout used to kill occasionally errant/"stuck" processes (note: 'release' testing takes ~1 hour; 'debug' testing takes ~2.5 hours)
+# * `gl_public_submodule_commit=` disables testing for use of a "public" gnulib commit (which will fail when using shallow gnulib checkouts)
+# * `srcdir=..` specifies the GNU source directory for tests (fixing failing/confused 'tests/factor/tNN.sh' tests and causing no harm to other tests)
+#shellcheck disable=SC2086
+timeout -sKILL 4h make -j "$(nproc)" check ${RUN_TEST} 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
+
+if test -z "$1" && test -n "$CI"; then
+    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
diff --git a/util/show-code_coverage.sh b/util/show-code_coverage.sh
index 365041434..3f51462c9 100755
--- a/util/show-code_coverage.sh
+++ b/util/show-code_coverage.sh
@@ -1,16 +1,30 @@
 #!/bin/sh
 
-# spell-checker:ignore (vars) OSID
+# spell-checker:ignore (vars) OSID binfmt
 
-ME_dir="$(dirname -- $(readlink -fm -- "$0"))"
+ME="${0}"
+ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
 export COVERAGE_REPORT_DIR="${REPO_main_dir}/target/debug/coverage-nix"
 
-"${ME_dir}/build-code_coverage.sh"
-if [ $? -ne 0 ]; then exit 1 ; fi
+if ! "${ME_dir}/build-code_coverage.sh"; then exit 1; fi
 
-case ";$OSID_tags;" in
-    *";wsl;"* ) powershell.exe -c $(wslpath -w "${COVERAGE_REPORT_DIR}"/index.html) ;;
-    * ) xdg-open --version >/dev/null 2>&1 && xdg-open "${COVERAGE_REPORT_DIR}"/index.html || echo "report available at '\"${COVERAGE_REPORT_DIR}\"/index.html'" ;;
-esac ;
+# WSL?
+if [ -z "${OSID_tags}" ]; then
+    if [ -e '/proc/sys/fs/binfmt_misc/WSLInterop' ] && (grep '^enabled$' '/proc/sys/fs/binfmt_misc/WSLInterop' >/dev/null); then
+        __="wsl"
+        case ";${OSID_tags};" in ";;") OSID_tags="$__" ;; *";$__;"*) ;; *) OSID_tags="$__;$OSID_tags" ;; esac
+        unset __
+        # Windows version == <major>.<minor>.<build>.<revision>
+        # Release ID; see [Release ID/Version vs Build](https://winreleaseinfoprod.blob.core.windows.net/winreleaseinfoprod/en-US.html)[`@`](https://archive.is/GOj1g)
+        OSID_wsl_build="$(uname -r | sed 's/^[0-9.][0-9.]*-\([0-9][0-9]*\)-.*$/\1/g')"
+        OSID_wsl_revision="$(uname -v | sed 's/^#\([0-9.][0-9.]*\)-.*$/\1/g')"
+        export OSID_wsl_build OSID_wsl_revision
+    fi
+fi
+
+case ";${OSID_tags};" in
+    *";wsl;"*) powershell.exe -c "$(wslpath -w "${COVERAGE_REPORT_DIR}"/index.html)" ;;
+    *) xdg-open --version >/dev/null 2>&1 && xdg-open "${COVERAGE_REPORT_DIR}"/index.html || echo "report available at '\"${COVERAGE_REPORT_DIR}\"/index.html'" ;;
+esac
diff --git a/util/show-utils.sh b/util/show-utils.sh
index b4a613d9b..0db72e1c4 100755
--- a/util/show-utils.sh
+++ b/util/show-utils.sh
@@ -15,17 +15,13 @@ default_utils="base32 base64 basename cat cksum comm cp cut date dircolors dirna
 
 project_main_dir="${ME_parent_dir_abs}"
 # printf 'project_main_dir="%s"\n' "${project_main_dir}"
-cd "${project_main_dir}"
+cd "${project_main_dir}" &&
 
-# `jq` available?
-unset JQ
-jq --version 1>/dev/null 2>&1
-if [ $? -eq 0 ]; then export JQ="jq"; fi
-
-if [ -z "${JQ}" ]; then
-    echo 'WARN: missing `jq` (install with `sudo apt install jq`); falling back to default (only fully cross-platform) utility list' 1>&2
-    echo $default_utils
-else
-    cargo metadata $* --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string | sub(\"^uu_\"; \"\")] | sort | join(\" \")"
-    # cargo metadata $* --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string] | sort | join(\" \")"
-fi
+    # `jq` available?
+    if ! jq --version 1>/dev/null 2>&1; then
+        echo "WARN: missing \`jq\` (install with \`sudo apt install jq\`); falling back to default (only fully cross-platform) utility list" 1>&2
+        echo "$default_utils"
+    else
+        cargo metadata "$*" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string | sub(\"^uu_\"; \"\")] | sort | join(\" \")"
+        # cargo metadata "$*" --format-version 1 | jq -r "[.resolve.nodes[] | { id: .id, deps: [.deps[] | { name:.name, pkg:.pkg }] }] | .[] | select(.id|startswith(\"coreutils\")) | [.deps[] | select((.name|startswith(\"uu_\")) or (.pkg|startswith(\"uu_\")))] | [.[].pkg | match(\"^\\\w+\";\"g\")] | [.[].string] | sort | join(\" \")"
+    fi
diff --git a/util/test-repo-whitespace.BAT b/util/test-repo-whitespace.BAT
index c63415295..6e2fce557 100644
--- a/util/test-repo-whitespace.BAT
+++ b/util/test-repo-whitespace.BAT
@@ -1,19 +1,21 @@
 @setLocal
 @echo off
 
-:: `test-repo-whitespace [DIR]...`
+:: `test-repo-whitespace [DIR]...` v2022.01.01
 :: style inspector ~ whitespace: find nonconforming files in repository
 
-:: Copyright (C) 2016-2020 ~ Roy Ivy III <rivy.dev@gmail.com>
+:: Copyright (C) 2016-2022 ~ Roy Ivy III <rivy.dev@gmail.com>
 :: License: MIT/Apache-2.0 (see https://opensource.org/licenses/Apache-2.0 , https://opensource.org/licenses/MIT)
 :: * this software is provided for free, WITHOUT ANY EXPRESS OR IMPLIED WARRANTY (see the license for details)
 
-:: spell-checker:ignore (ignore) CTYPE POSIX RETval RETvar akefile makefile makefiles multiline
 :: spell-checker:ignore (shell/cmd) COMSPEC ERRORLEVEL
+:: spell-checker:ignore () CTYPE POSIX Tval Tvar akefile makefile makefiles multiline testdata
 
 :config
-set "_exclude_dir=(?i)[_.#]build|[.]git|[.]gpg|[.]vs|fixtures|vendor"
-set "_exclude=(?i)[.](cache|dll|exe|gif|gz|zip)$"
+set "_exclude_dirs_rx=(?i)[_.#]build|[.]git|[.]gpg|[.]obj|[.]vs|fixtures|node_modules|target|testdata|test-resources|vendor"
+set "_exclude_files_rx=(?i)[.](cache|dll|exe|gif|gz|ico|png|zip)$"
+set "_crlf_files_rx=(?i)[.](bat|cmd|csv)$"
+set "_tabbed_files_rx=(?i)^^(.*[.]go|go[.](mod|sum)|(GNU)?[Mm]akefile([.].*)?)$"
 :config_done
 
 set _dp0=%~dp0.
@@ -34,36 +36,36 @@ if /i "%LC_CTYPE%"=="posix" (set "LC_CTYPE=C") &:: `pcregrep` doesn't understand
 set "ERRORLEVEL="
 set "ERROR="
 :: 1. Test for TABs within leading whitespace (except go files makefiles)
-"%PCREGREP%" -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" --exclude "(?i)[.]go$" --exclude "go[.](mod|sum)" --exclude "(GNU)?[Mm]akefile([.].*)?" --count --files-with-matches --recursive "^\s*\t" %dirs%
+"%PCREGREP%" -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" --exclude "%_tabbed_files_rx%" --count --files-with-matches --recursive "^\s*\t" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set ERROR=1 & echo ERROR: files found with TABs within leading whitespace [file:#lines_matched])
 
 :: 2. Test for lines with internal TABs
-"%PCREGREP%" -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" --count --files-with-matches --recursive "^.*[^\t]\t" %dirs%
+"%PCREGREP%" -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" --count --files-with-matches --recursive "^.*[^\t]\t" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set ERROR=1 & echo ERROR: files found with lines containing internal TABs [file:#lines_matched])
 
 :: 3. Test that makefiles have ONLY initial-TAB leading whitespace
-"%PCREGREP%" -I --exclude-dir "%_exclude_dir%" --include "(GNU)?[Mm]akefile([.].*)?" --exclude "[.](to|y)ml$" --recursive --line-number --invert-match "^([\t]\s*\S|\S|$)" %dirs%
+"%PCREGREP%" -I --exclude-dir "%_exclude_dirs_rx%" --include "(GNU)?[Mm]akefile([.].*)?" --exclude "[.](to|y)ml$" --recursive --line-number --invert-match "^([\t]\s*\S|\S|$)" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set ERROR=1 & echo ERROR: Makefiles found with lines having non-TAB leading whitespace [file:line_number])
 
 :: 4. Test for non-LF line endings
 set "HAVE_NonLF_ERROR="
-"%PCREGREP%" --buffer-size=1M -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" -NLF --files-with-matches --multiline --recursive "\r[^\n]" %dirs%
+"%PCREGREP%" --buffer-size=1M -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" -NLF --files-with-matches --multiline --recursive "\r[^\n]" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set HAVE_NonLF_ERROR=1 & echo ## files found with CR line endings)
-"%PCREGREP%" --buffer-size=1M -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" --exclude "(?i)\.bat$|\.cmd$" -NLF --files-with-matches --multiline --recursive "\r\n" %dirs%
+"%PCREGREP%" --buffer-size=1M -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" --exclude "%_crlf_files_rx%" -NLF --files-with-matches --multiline --recursive "\r\n" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set HAVE_NonLF_ERROR=1 & echo ## files found with CRLF line endings)
 if DEFINED HAVE_NonLF_ERROR ( set ERROR=1 & echo ERROR: files found with non-LF line endings)
 
 :: 5. Test for files without trailing newline
-:: "%PCREGREP%" -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" --files-without-match --multiline --recursive "\r?[\r\n]\z" %dirs%
-"%PCREGREP%" -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" --files-with-matches --multiline --recursive "\z" %dirs%
+:: "%PCREGREP%" -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" --files-without-match --multiline --recursive "\r?[\r\n]\z" %dirs%
+"%PCREGREP%" -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" --files-with-matches --multiline --recursive "\z" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set ERROR=1 & echo ERROR: files found without trailing newline)
 
 :: 6. Test for files with lines having trailing whitespace
-"%PCREGREP%" -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" --recursive --line-number "\s$" %dirs%
+"%PCREGREP%" -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" --recursive --line-number "\s$" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set ERROR=1 & echo ERROR: files found with lines having trailing whitespace [file:line_number])
 
 :: 7. Test for files with BOM
-"%PCREGREP%" -I --exclude-dir "%_exclude_dir%" --exclude "%_exclude%" --files-with-matches --multiline --recursive "\A[\xEF][\xBB][\xBF]" %dirs%
+"%PCREGREP%" -I --exclude-dir "%_exclude_dirs_rx%" --exclude "%_exclude_files_rx%" --files-with-matches --multiline --recursive "\A[\xEF][\xBB][\xBF]" %dirs%
 if NOT "%ERRORLEVEL%" == "1" ( set ERROR=1 & echo ERROR: files found with leading BOM)
 
 :script_done
diff --git a/util/update-version.sh b/util/update-version.sh
index cbb811300..7daa3c08e 100755
--- a/util/update-version.sh
+++ b/util/update-version.sh
@@ -1,20 +1,29 @@
-#!/bin/bash
+#!/bin/sh
 # This is a stupid helper. I will mass replace all versions (including other crates)
 # So, it should be triple-checked
 
+# How to ship a new release:
+# 1) update this script
+# 2) run it: sh util/update-version.sh
+# 3) Do a spot check with "git diff"
+# 4) cargo test --release --features unix
+# 5) Run util/publish.sh in dry mode (it will fail as packages needs more recent version of uucore)
+# 6) Run util/publish.sh --do-it
+# 7) In some cases, you might have to fix dependencies and run import
 
-FROM="0.0.7"
-TO="0.0.8"
+FROM="0.0.12"
+TO="0.0.13"
 
-UUCORE_PROCS_FROM="0.0.6"
-UUCORE_PROCS_TO="0.0.7"
+UUCORE_PROCS_FROM="0.0.12"
+UUCORE_PROCS_TO="0.0.13"
 
-UUCORE_FROM="0.0.9"
-UUCORE_TO="0.0.10"
+UUCORE_FROM="0.0.12"
+UUCORE_TO="0.0.13"
 
 PROGS=$(ls -1d src/uu/*/Cargo.toml src/uu/stdbuf/src/libstdbuf/Cargo.toml Cargo.toml src/uu/base64/Cargo.toml)
 
 # update the version of all programs
+#shellcheck disable=SC2086
 sed -i -e "s|version = \"$FROM\"|version = \"$TO\"|" $PROGS
 
 # Update uucore_procs
@@ -27,6 +36,8 @@ sed -i -e "s|= { optional=true, version=\"$FROM\", package=\"uu_|= { optional=tr
 # Update uucore itself
 sed -i -e "s|version = \"$UUCORE_FROM\"|version = \"$UUCORE_TO\"|" src/uucore/Cargo.toml
 # Update crates using uucore
+#shellcheck disable=SC2086
 sed -i -e "s|uucore = { version=\">=$UUCORE_FROM\",|uucore = { version=\">=$UUCORE_TO\",|" $PROGS
 # Update crates using uucore_procs
+#shellcheck disable=SC2086
 sed -i -e "s|uucore_procs = { version=\">=$UUCORE_PROCS_FROM\",|uucore_procs = { version=\">=$UUCORE_PROCS_TO\",|" $PROGS