Merge pull request #1943 from tmccombs/archive-script

build: Create archive script
Merge pull request #2102 from tmccombs/changelog-update
2026-08-31 01:15:43 +08:00 · 2026-08-27 23:52:23 -06:00 · 2026-08-26 09:54:02 -06:00 · 2026-08-26 02:12:47 -06:00 · 2026-08-26 01:54:19 -06:00 · 2026-08-26 01:27:33 -06:00
47 changed files with 3798 additions and 1597 deletions
@@ -0,0 +1,9 @@
+# On Windows MSVC, statically link the C runtime so that the resulting EXE does
+# not depend on the vcruntime DLL.
+#
+# See: https://github.com/sharkdp/fd/issues/1874
+
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
+[target.i686-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]
@@ -4,7 +4,11 @@ updates:
    directory: "/"
    schedule:
      interval: "monthly"
+    cooldown:
+      default-days: 7
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "daily"
+    cooldown:
+      default-days: 7
@@ -13,12 +13,17 @@ on:
    tags:
      - '*'

+permissions:
+  contents: read
+
 jobs:
  crate_metadata:
    name: Extract crate metadata
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v7.0.1
+      with:
+        persist-credentials: false
    - name: Extract crate information
      id: crate_metadata
      run: |
@@ -36,21 +41,37 @@ jobs:

  ensure_cargo_fmt:
    name: Ensure 'cargo fmt' has been run
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    steps:
    - uses: dtolnay/rust-toolchain@stable
      with:
        components: rustfmt
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v7.0.1
+      with:
+        persist-credentials: false
    - run: cargo fmt -- --check

+  lint_check:
+    name: Ensure 'cargo clippy' has no warnings
+    runs-on: ubuntu-latest
+    steps:
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: clippy
+    - uses: actions/checkout@v7.0.1
+      with:
+        persist-credentials: false
+    - run: cargo clippy --all-targets --all-features -- -Dwarnings
+
  min_version:
    name: Minimum supported rust version
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    needs: crate_metadata
    steps:
    - name: Checkout source code
-      uses: actions/checkout@v4
+      uses: actions/checkout@v7.0.1
+      with:
+        persist-credentials: false

    - name: Install rust toolchain (v${{ needs.crate_metadata.outputs.msrv }})
      uses: dtolnay/rust-toolchain@master
@@ -58,39 +79,50 @@ jobs:
        toolchain: ${{ needs.crate_metadata.outputs.msrv }}
        components: clippy
    - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
-      run: cargo clippy --locked --all-targets ${{ env.MSRV_FEATURES }}
+      run: cargo clippy --locked --all-targets "${MSRV_FEATURES}"
    - name: Run tests
-      run: cargo test --locked ${{ env.MSRV_FEATURES }}
+      run: cargo test --locked "${MSRV_FEATURES}"

  build:
-    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
+    name: '${{ matrix.job.target }} (${{ matrix.job.os }})'
    runs-on: ${{ matrix.job.os }}
    needs: crate_metadata
+    permissions:
+      id-token: write
+      contents: write
+      attestations: write
    strategy:
      fail-fast: false
      matrix:
        job:
-          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-20.04, use-cross: true }
-          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-20.04, use-cross: true }
-          - { target: arm-unknown-linux-musleabihf, os: ubuntu-20.04, use-cross: true }
-          - { target: i686-pc-windows-msvc        , os: windows-2019                  }
-          - { target: i686-unknown-linux-gnu      , os: ubuntu-20.04, use-cross: true }
-          - { target: i686-unknown-linux-musl     , os: ubuntu-20.04, use-cross: true }
-          - { target: x86_64-apple-darwin         , os: macos-12                      }
-          - { target: x86_64-pc-windows-gnu       , os: windows-2019                  }
-          - { target: x86_64-pc-windows-msvc      , os: windows-2019                  }
-          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-20.04, use-cross: true }
-          - { target: x86_64-unknown-linux-musl   , os: ubuntu-20.04, use-cross: true }
+          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-24.04, use-cross: true }
+          - { target: aarch64-unknown-linux-musl  , os: ubuntu-24.04, use-cross: true }
+          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-24.04, use-cross: true }
+          - { target: arm-unknown-linux-musleabihf, os: ubuntu-24.04, use-cross: true }
+          - { target: i686-pc-windows-msvc        , os: windows-2025                  }
+          - { target: i686-unknown-linux-gnu      , os: ubuntu-24.04, use-cross: true }
+          - { target: i686-unknown-linux-musl     , os: ubuntu-24.04, use-cross: true }
+          - { target: x86_64-apple-darwin         , os: macos-26-intel                }
+          - { target: aarch64-apple-darwin        , os: macos-26                      }
+          - { target: x86_64-pc-windows-gnu       , os: windows-2025                  }
+          - { target: x86_64-pc-windows-msvc      , os: windows-2025                  }
+          - { target: aarch64-pc-windows-msvc     , os: windows-11-arm                }
+          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-24.04, use-cross: true }
+          - { target: x86_64-unknown-linux-musl   , os: ubuntu-24.04, use-cross: true }
    env:
-      BUILD_CMD: cargo
+      BUILD_CMD: "${{ matrix.job.use-cross && 'cross' || 'cargo' }}"
+      target: ${{ matrix.job.target }}
+      name: ${{ needs.crate_metadata.outputs.name }}
    steps:
    - name: Checkout source code
-      uses: actions/checkout@v4
+      uses: actions/checkout@v7.0.1
+      with:
+        persist-credentials: false

    - name: Install prerequisites
      shell: bash
      run: |
-        case ${{ matrix.job.target }} in
+        case ${target} in
          arm-unknown-linux-*) 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
@@ -99,18 +131,22 @@ jobs:
      uses: dtolnay/rust-toolchain@stable
      with:
        targets: ${{ matrix.job.target }}
+        toolchain: "stable"

    - name: Install cross
      if: matrix.job.use-cross
-      uses: taiki-e/install-action@v2
-      with:
-        tool: cross
-
-    - name: Overwrite build command env variable
-      if: matrix.job.use-cross
-      shell: bash
-      run: echo "BUILD_CMD=cross" >> $GITHUB_ENV
-
+      env:
+        cross_version: "v0.2.5"
+        package_name: "cross-x86_64-unknown-linux-gnu.tar.gz"
+        GH_TOKEN: "${{ github.token }}"
+      run: |
+        dir="$HOME/.local/bin/"
+        mkdir -p "$dir"
+        gh release download --repo cross-rs/cross  \
+          --pattern "${package_name}" -O - "${cross_version}" \
+          | tar -C "$dir" -xz
+        echo "$dir" >> $GITHUB_PATH
+        echo "Installed cross $cross_version" >> $GITHUB_STEP_SUMMARY
    - name: Show version information (Rust, cargo, GCC)
      shell: bash
      run: |
@@ -123,7 +159,7 @@ jobs:

    - name: Build
      shell: bash
-      run: $BUILD_CMD build --locked --release --target=${{ matrix.job.target }}
+      run: $BUILD_CMD build --locked --release --target="${target}"

    - name: Set binary name & path
      id: bin
@@ -131,13 +167,13 @@ jobs:
      run: |
        # Figure out suffix of binary
        EXE_suffix=""
-        case ${{ matrix.job.target }} in
+        case ${target} in
          *-pc-windows-*) EXE_suffix=".exe" ;;
        esac;

        # Setup paths
-        BIN_NAME="${{ needs.crate_metadata.outputs.name }}${EXE_suffix}"
-        BIN_PATH="target/${{ matrix.job.target }}/release/${BIN_NAME}"
+        BIN_NAME="${name}${EXE_suffix}"
+        BIN_PATH="target/${target}/release/${BIN_NAME}"

        # Let subsequent steps know where to find the binary
        echo "BIN_PATH=${BIN_PATH}" >> $GITHUB_OUTPUT
@@ -149,12 +185,17 @@ jobs:
      run: |
        # test only library unit tests and binary for arm-type targets
        unset CARGO_TEST_OPTIONS
-        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--bin ${{ needs.crate_metadata.outputs.name }}" ;; esac;
+        case ${target} in
+        arm-* | aarch64-*)
+          CARGO_TEST_OPTIONS="--bin=${name}" ;;
+        esac
        echo "CARGO_TEST_OPTIONS=${CARGO_TEST_OPTIONS}" >> $GITHUB_OUTPUT

    - name: Run tests
      shell: bash
-      run: $BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
+      env:
+        cargo_test_options: ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
+      run: $BUILD_CMD test --locked --target="${target}" "${cargo_test_options}"

    - name: Generate completions
      id: completions
@@ -164,163 +205,39 @@ jobs:
    - name: Create tarball
      id: package
      shell: bash
-      run: |
-        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
-        PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ matrix.job.target }}
-        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
-        echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT
-
-        PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"
-        ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
-        mkdir -p "${ARCHIVE_DIR}"
-
-        # Binary
-        cp "${{ steps.bin.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
-
-        # README, LICENSE and CHANGELOG files
-        cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "CHANGELOG.md" "$ARCHIVE_DIR"
-
-        # Man page
-        cp 'doc/${{ needs.crate_metadata.outputs.name }}.1' "$ARCHIVE_DIR"
-
-        # Autocompletion files
-        cp -r autocomplete "${ARCHIVE_DIR}"
-
-        # base compressed package
-        pushd "${PKG_STAGING}/" >/dev/null
-        case ${{ matrix.job.target }} in
-          *-pc-windows-*) 7z -y a "${PKG_NAME}" "${PKG_BASENAME}"/* | tail -2 ;;
-          *) tar czf "${PKG_NAME}" "${PKG_BASENAME}"/* ;;
-        esac;
-        popd >/dev/null
-
-        # Let subsequent steps know where to find the compressed package
-        echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT
+      run: bash scripts/create-archive.sh
+      env:
+        BIN_PATH: ${{ steps.bin.outputs.BIN_PATH }}
+        TARGET: ${{ env.target }}
+        ARCHIVE_NAME: ${{ env.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ env.target }}
+        PKG_STAGING: "${{ env.CICD_INTERMEDIATES_DIR }}/package"

    - name: Create Debian package
      id: debian-package
      shell: bash
      if: startsWith(matrix.job.os, 'ubuntu')
-      run: |
-        COPYRIGHT_YEARS="2018 - "$(date "+%Y")
-        DPKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/debian-package"
-        DPKG_DIR="${DPKG_STAGING}/dpkg"
-        mkdir -p "${DPKG_DIR}"
-
-        DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}
-        DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }}-musl
-        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-musl ; DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }} ;; esac;
-        DPKG_VERSION=${{ needs.crate_metadata.outputs.version }}
-
-        unset DPKG_ARCH
-        case ${{ matrix.job.target }} in
-          aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
-          arm-*-linux-*hf) DPKG_ARCH=armhf ;;
-          i686-*-linux-*) DPKG_ARCH=i686 ;;
-          x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
-          *) DPKG_ARCH=notset ;;
-        esac;
-
-        DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
-        echo "DPKG_NAME=${DPKG_NAME}" >> $GITHUB_OUTPUT
-
-        # Binary
-        install -Dm755 "${{ steps.bin.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.bin.outputs.BIN_NAME }}"
-
-        # Man page
-        install -Dm644 'doc/${{ needs.crate_metadata.outputs.name }}.1' "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
-        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
-
-        # Autocompletion files
-        install -Dm644 'autocomplete/fd.bash' "${DPKG_DIR}/usr/share/bash-completion/completions/${{ needs.crate_metadata.outputs.name }}"
-        install -Dm644 'autocomplete/fd.fish' "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ needs.crate_metadata.outputs.name }}.fish"
-        install -Dm644 'autocomplete/_fd' "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ needs.crate_metadata.outputs.name }}"
-
-        # README and LICENSE
-        install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
-        install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-MIT"
-        install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-APACHE"
-        install -Dm644 "CHANGELOG.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
-        gzip -n --best "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
-
-        cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
-        Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-        Upstream-Name: ${{ needs.crate_metadata.outputs.name }}
-        Source: ${{ needs.crate_metadata.outputs.homepage }}
-
-        Files: *
-        Copyright: ${{ needs.crate_metadata.outputs.maintainer }}
-        Copyright: $COPYRIGHT_YEARS ${{ needs.crate_metadata.outputs.maintainer }}
-        License: Apache-2.0 or MIT
-
-        License: Apache-2.0
-          On Debian systems, the complete text of the Apache-2.0 can be found in the
-          file /usr/share/common-licenses/Apache-2.0.
-
-        License: MIT
-          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 the
-          Software without restriction, including without
-          limitation the rights to use, copy, modify, merge,
-          publish, distribute, sublicense, and/or sell copies of
-          the Software, and to permit persons to whom the Software
-          is furnished to do so, subject to the following
-          conditions:
-          .
-          The above copyright notice and this permission notice
-          shall be included in all copies or substantial portions
-          of the Software.
-          .
-          THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-          ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-          TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-          PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-          SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-          CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-          OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-          IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-          DEALINGS IN THE SOFTWARE.
-        EOF
-          chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"
-
-          # control file
-          mkdir -p "${DPKG_DIR}/DEBIAN"
-          cat > "${DPKG_DIR}/DEBIAN/control" <<EOF
-        Package: ${DPKG_BASENAME}
-        Version: ${DPKG_VERSION}
-        Section: utils
-        Priority: optional
-        Maintainer: ${{ needs.crate_metadata.outputs.maintainer }}
-        Homepage: ${{ needs.crate_metadata.outputs.homepage }}
-        Architecture: ${DPKG_ARCH}
-        Provides: ${{ needs.crate_metadata.outputs.name }}
-        Conflicts: ${DPKG_CONFLICTS}
-        Description: simple, fast and user-friendly alternative to find
-          fd is a program to find entries in your filesystem.
-          It is a simple, fast and user-friendly alternative to find.
-          While it does not aim to support all of finds powerful functionality, it provides
-          sensible (opinionated) defaults for a majority of use cases.
-        EOF
-
-        DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
-        echo "DPKG_PATH=${DPKG_PATH}" >> $GITHUB_OUTPUT
-
-        # build dpkg
-        fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"
+      run: bash scripts/create-deb.sh
+      env:
+        TARGET: ${{ matrix.job.target }}
+        DPKG_VERSION: ${{ needs.crate_metadata.version }}
+        BIN_PATH: ${{ steps.bin.outputs.BIN_PATH }}

    - name: "Artifact upload: tarball"
-      uses: actions/upload-artifact@master
+      id: upload-tarball
+      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
      with:
        name: ${{ steps.package.outputs.PKG_NAME }}
        path: ${{ steps.package.outputs.PKG_PATH }}
+        compression-level: 0 # tarball is already compressed

    - name: "Artifact upload: Debian package"
-      uses: actions/upload-artifact@master
+      id: upload-deb
+      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
      if: steps.debian-package.outputs.DPKG_NAME
      with:
        name: ${{ steps.debian-package.outputs.DPKG_NAME }}
        path: ${{ steps.debian-package.outputs.DPKG_PATH }}
+        compression-level: 0 # deb files are already compressed

    - name: Check for release
      id: is-release
@@ -329,8 +246,16 @@ jobs:
        unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi
        echo "IS_RELEASE=${IS_RELEASE}" >> $GITHUB_OUTPUT

+    - name: "Attest artifacts"
+      uses: actions/attest@508db95dd578ae2727ebd6217d5ba78e4fbda05d # v4
+      if: steps.is-release.outputs.IS_RELEASE
+      with:
+        subject-path: |
+          ${{ steps.package.outputs.PKG_PATH }}
+          ${{ steps.debian-package.outputs.DPKG_PATH }}
+
    - name: Publish archives and packages
-      uses: softprops/action-gh-release@v1
+      uses: softprops/action-gh-release@3d0d9888cb7fd7b750713d6e236d1fcb99157228 # v3.0.2
      if: steps.is-release.outputs.IS_RELEASE
      with:
        files: |
@@ -341,11 +266,11 @@ jobs:

  winget:
    name: Publish to Winget
-    runs-on: windows-latest # Action can only run on Windows
+    runs-on: ubuntu-latest
    needs: build
    if: startsWith(github.ref, 'refs/tags/v')
    steps:
-      - uses: vedantmgoyal2009/winget-releaser@v2
+      - uses: vedantmgoyal9/winget-releaser@4ffc7888bffd451b357355dc214d43bb9f23917e # v2
        with:
          identifier: sharkdp.fd
          installers-regex: '-pc-windows-msvc\.zip$'
@@ -1,3 +1,4 @@
 target/
 /autocomplete/
+/package/
 **/*.rs.bk
@@ -1,3 +1,184 @@
+# Upcoming Release
+
+## Features
+-
+
+## Bugfixes
+-
+
+# 10.5.0
+
+## Features
+- Add `--ignore-parent` option to override `--no-ignore-parent`, see #1958 (@tmchow)
+- Add `--exact` option to match the entire filename exactly (literal, non-substring).
+
+## Bugfixes
+- Sanitize control characters and bidirectional override characters in filenames
+  when output goes to a terminal, to prevent terminal escape-sequence injection.
+  Also reject a placeholder as the executable for `--exec-batch`, while still
+  allowing it for `--exec`.
+- Handle invalid working directories gracefully when using `--full-path`, see #1900 (@Xavrir).
+- Fire the "search pattern contains a path separator" diagnostic for any pattern containing `/`, not just patterns that happen to name an existing directory. Preserves the legacy Windows behaviour that also flags native `\` separators when the pattern resolves to a real directory. See #1873.
+- Also fire the "search pattern contains a path separator" diagnostic for `--and` patterns, not only the primary positional pattern. `--and` patterns are matched against the file name just like the primary pattern, so a path separator in them silently returned zero results. See #1873.
+- Fix bug where passing "-" as a directory argument didn't actually search that directory, see #849 (@Sean-Kenneth-Doherty).
+- Fix panic when `--changed-before`/`--changed-within` is given an out-of-range `@` Unix timestamp; the value is now rejected gracefully, see #2081 (@nikolauspschuetz).
+
+# 10.4.2
+
+## Bugfixes
+- Fixed performance regression due to `--ignore-contain`; see #1913 and #1914
+
+# 10.4.1
+
+This is just a re-release of 10.4.0 due to an issue with the 10.4.0 release.
+
+# 10.4.0
+
+## Features
+- Add `--ignore-contain` option to ignore directories containing a named entry (e.g. to ignore [`CACHEDIR.TAG`](https://bford.info/cachedir/)); see #1727 (@fischman).
+
+## Bugfixes
+
+- Fix Windows hyperlink generation for paths with spaces. (#1872)
+
+- `--print0` combined with `--exec` will now print a `\0` between the output of each entry. Note that if there are multiple instances
+  of `--exec`, the `\0` will be between each _set_ of commands, _not_ between each individual command run. Fixes #1797.
+
+- Several bugs were fixed by an update to the `ignore` library used for handling ignore rules
+    - #1506
+    - #1667
+    - #1813
+
+- Fix completions for alias `fdfind` in deb release, see #1888 (@skane-lukas)
+
+## Changes
+
+- Minimum required rust version has been increased to 1.90.0. Notably, this means dropping fully support for intel Mac and Windows 7.
+- Statically link the CRT for MSVC builds via Cargo config to avoid runtime DLL dependencies, see #1874 (@FidelSch)
+
+# 10.3.0
+
+## Features
+
+- Add a hidden `--mindepth` alias for `--min-depth`. (#1617)
+
+
+## Bugfixes
+
+
+## Changes
+
+- Replace `humantime` crate and `chrono` crate with `jiff` crate, see #1690 (@sorairolake). This has some small changes to the
+  way dates given to options such `--changed-within` and `--changed-before` including:
+  - 'M' no longer means "month", as that could be confusing with minutes. Use "mo", "mos", "month" or "months" instead.
+  - month and year now account for variability in the calander rather than being a hard-coded number of seconds. That is probably
+    what you would expect, but it is a slight change in behavior.
+- aarch64 Windows was added to CI and release artifacts
+- Many dependencies were updated
+- Better support building on Illumos (there is no automated testing, but some known issues were fixed)
+
+## Other
+
+This will be the last release that has been tested on x86_64 Mac OS, since GitHub is
+dropping support for runners with that hardware.
+
+It may also be the last release to use a version of Rust with tier-1 support for
+x86_64/intel Macs and Windows 7.
+
+
+# 10.2.0
+
+## Features
+
+- Add --hyperlink option to add OSC 8 hyperlinks to output
+
+
+## Bugfixes
+
+
+## Changes
+
+- Build windows releases with rust 1.77 so windows 7 is still supported
+- Deb packages now include symlink for fdfind to be more consistent with official packages
+
+
+## Other
+
+# 10.1.0
+
+## Features
+
+- Allow passing an optional argument to `--strip-cwd-prefix` of "always", "never", or "auto". to force whether the cwd prefix is stripped or not.
+- Add a `--format` option which allows using a format template for direct ouput similar to the template used for `--exec`. (#1043)
+
+## Bugfixes
+- Fix aarch64 page size again. This time it should actually work. (#1085, #1549) (@tavianator)
+
+
+## Other
+
+- aarch64-apple-darwin target added to builds on the release page. Note that this is a tier 2 rust target.
+
+# v10.0.0
+
+## Features
+
+- Add `dir` as an alias to `directory` when using `-t` \ `--type`, see #1460 and #1464 (@Ato2207).
+- Add support for @%s date format in time filters similar to GNU date (seconds since Unix epoch for --older/--newer), see #1493 (@nabellows)
+- Breaking: No longer automatically ignore `.git` when using `--hidden` with vcs ignore enabled. This reverts the change in v9.0.0. While this feature
+  was often useful, it also broke some existing workflows, and there wasn't a good way to opt out of it. And there isn't really a good way for us to add
+  a way to opt out of it. And you can easily get similar behavior by adding `.git/` to your global fdignore file.
+    See #1457.
+
+## Bugfixes
+
+- Respect NO_COLOR environment variable with `--list-details` option. (#1455)
+- Fix bug that would cause hidden files to be included despite gitignore rules
+  if search path is "." (#1461, BurntSushi/ripgrep#2711).
+- aarch64 builds now use 64k page sizes with jemalloc. This fixes issues on some systems, such as ARM Macs that
+  have a larger system page size than the system that the binary was built on. (#1547)
+- Address [CVE-2024-24576](https://blog.rust-lang.org/2024/04/09/cve-2024-24576.html), by increasing minimum rust version.
+
+
+## Changes
+- Minimum supported rust version is now 1.77.2
+
+
+# v9.0.0
+
+## Performance
+
+- Performance has been *significantly improved*, both due to optimizations in the underlying `ignore`
+  crate (#1429), and in `fd` itself (#1422, #1408, #1362) - @tavianator.
+  [Benchmarks results](https://gist.github.com/tavianator/32edbe052f33ef60570cf5456b59de81) show gains
+  of 6-8x for full traversals of smaller directories (100k files) and up to 13x for larger directories (1M files).
+
+- The default number of threads is now constrained to be at most 64. This should improve startup time on
+  systems with many CPU cores. (#1203, #1410, #1412, #1431) - @tmccombs and @tavianator
+
+- New flushing behavior when writing output to stdout, providing better performance for TTY and non-TTY
+  use cases, see #1452 and #1313 (@tavianator).
+
+## Features
+
+- Support character and block device file types, see #1213 and #1336 (@cgzones)
+- Breaking: `.git/` is now ignored by default when using `--hidden` / `-H`, use `--no-ignore` / `-I` or
+  `--no-ignore-vcs` to override, see #1387 and #1396 (@skoriop)
+
+## Bugfixes
+
+- Fix `NO_COLOR` support, see #1421 (@acuteenvy)
+
+## Other
+
+- Fixed documentation typos, see #1409 (@marcospb19)
+
+## Thanks
+
+Special thanks to @tavianator for his incredible work on performance in the `ignore` crate and `fd` itself.
+
+
+
 # v8.7.1

 ## Bugfixes
@@ -1,6 +1,6 @@
 ## Contributing to *fd*

-**Thank you very much for considering to contribute to this project!**
+**Thank you very much for considering contributing to this project!**

 We welcome any form of contribution:

@@ -10,6 +10,23 @@ We welcome any form of contribution:
 **Note**: Before you take the time to open a pull request, please open a ticket first. This will
 give us the chance to discuss any potential changes first.

+## Pull Request Expectations
+
+1. Your contribution should be high quality, and best effort. In particular, please don't make a Pull Request
+   that was created using generative AI unless you have reviewed it yourself and understand what it does, and be
+   able to meaningfully answer questions and make changes to it as needed.
+2. Your code should successfully compile and pass tests before publishing a Pull Request. It's understandable
+   if tests fail on one or two specific targets, but if the build doesn't pass for any targets, that is a signal
+   that the PR is low effort.
+3. It is your responsibility to ensure that the generated code does not violate any copyrights or patents. This is
+   true of all contributions, but is especially relevant when using an LLM that may be generating output that is
+   very similar or even identical to existing code with an incompatible license.
+4. If an AI coding assistant or other LLM tool was used, you must indicate that an AI tool was used, and to what extent it was used.
+5. AI should not be used to generate comments when communicating with maintainers. We expect communication with the maintainers,
+   including PR descriptions and comments, to be from humans, not from an AI. Using an AI to assist with grammar, spelling, and
+   proofreading or translating is acceptable, as long as the content and voice of the
+   message is your own.
+
 ## Add an entry to the changelog

 If your contribution changes the behavior of `fd` (as opposed to a typo-fix
@@ -1,10 +1,10 @@
 [package]
 authors = ["David Peter <mail@david-peter.de>"]
-build = "build.rs"
 categories = ["command-line-utilities"]
 description = "fd is a simple, fast and user-friendly alternative to find."
 exclude = ["/benchmarks/*"]
 homepage = "https://github.com/sharkdp/fd"
+documentation = "https://docs.rs/fd-find"
 keywords = [
    "search",
    "find",
@@ -16,9 +16,9 @@ license = "MIT OR Apache-2.0"
 name = "fd-find"
 readme = "README.md"
 repository = "https://github.com/sharkdp/fd"
-version = "8.7.1"
-edition= "2021"
-rust-version = "1.70.0"
+version = "10.5.0"
+edition= "2024"
+rust-version = "1.90.0"

 [badges.appveyor]
 repository = "sharkdp/fd"
@@ -30,43 +30,34 @@ repository = "sharkdp/fd"
 name = "fd"
 path = "src/main.rs"

-[build-dependencies]
-version_check = "0.9"
-
 [dependencies]
-nu-ansi-term = "0.49"
-argmax = "0.3.1"
-ignore = "0.4.20"
-num_cpus = "1.16"
-regex = "1.9.6"
-regex-syntax = "0.7"
-ctrlc = "3.2"
-humantime = "2.1"
+aho-corasick = "1.1"
+nu-ansi-term = "0.50"
+argmax = "0.4.0"
+ignore = "0.4.25"
+regex = "1.12.2"
+regex-syntax = "0.8"
+ctrlc = "3.5"
 globset = "0.4"
 anyhow = "1.0"
-etcetera = "0.8"
-normpath = "1.1.1"
-crossbeam-channel = "0.5.8"
-clap_complete = {version = "4.4.1", optional = true}
+etcetera = "0.11"
+normpath = "1.5.1"
+crossbeam-channel = "0.5.15"
+clap_complete = {version = "4.6.5", optional = true}
 faccess = "0.2.4"
+jiff = "0.2.27"

 [dependencies.clap]
-version = "4.4.6"
+version = "4.6.1"
 features = ["suggestions", "color", "wrap_help", "cargo", "derive"]

-[dependencies.chrono]
-version = "0.4.28"
-default-features = false
-features = ["std", "clock"]
-
 [dependencies.lscolors]
-version = "0.15"
+version = "0.21"
 default-features = false
 features = ["nu-ansi-term"]

 [target.'cfg(unix)'.dependencies]
-users = "0.11.0"
-nix = { version = "0.26.2", default-features = false, features = ["signal"] }
+nix = { version = "0.31.1", default-features = false, features = ["signal", "user", "hostname"] }

 [target.'cfg(all(unix, not(target_os = "redox")))'.dependencies]
 libc = "0.2"
@@ -74,14 +65,26 @@ libc = "0.2"
 # FIXME: Re-enable jemalloc on macOS
 # jemalloc is currently disabled on macOS due to a bug in jemalloc in combination with macOS
 # Catalina. See https://github.com/sharkdp/fd/issues/498 for details.
-[target.'cfg(all(not(windows), not(target_os = "android"), not(target_os = "macos"), not(target_os = "freebsd"), not(target_os = "openbsd"), not(all(target_env = "musl", target_pointer_width = "32")), not(target_arch = "riscv64")))'.dependencies]
-jemallocator = {version = "0.5.4", optional = true}
+# This has to be kept in sync with src/main.rs where the allocator for
+# the program is set.
+[target.'cfg(all(not(windows), not(target_os = "android"), not(target_os = "macos"), not(target_os = "freebsd"), not(target_os = "openbsd"), not(target_os = "illumos"), not(all(target_env = "musl", target_pointer_width = "32")), not(target_arch = "riscv64")))'.dependencies]
+tikv-jemallocator = {version = "0.7.0", optional = true}

 [dev-dependencies]
 diff = "0.1"
-tempfile = "3.6"
+tempfile = "3.27"
 filetime = "0.2"
-test-case = "3.1"
+test-case = "3.3"
+
+[profile.dev]
+debug = "line-tables-only"
+
+[profile.dev.package."*"]
+debug = false
+
+[profile.debugging]
+inherits = "dev"
+debug = true

 [profile.release]
 lto = true
@@ -89,7 +92,24 @@ strip = true
 codegen-units = 1

 [features]
-use-jemalloc = ["jemallocator"]
+use-jemalloc = ["tikv-jemallocator"]
 completions = ["clap_complete"]
 base = ["use-jemalloc"]
-default = ["use-jemalloc", "completions"]
+default = ["completions"]
+
+[package.metadata.binstall]
+pkg-url = "{ repo }/releases/download/v{ version }/{ name }-v{ version }-{ target }.{ archive-format }"
+bin-dir = "{ bin }-v{ version }-{ target }/{ bin }{ binary-ext }"
+pkg-fmt = "tgz"
+
+[package.metadata.binstall.overrides.x86_64-pc-windows-msvc]
+pkg-fmt = "zip"
+
+[package.metadata.binstall.overrides.x86_64-pc-windows-gnu]
+pkg-fmt = "zip"
+
+[package.metadata.binstall.overrides.i686-pc-windows-msvc]
+pkg-fmt = "zip"
+
+[package.metadata.binstall.overrides.aarch64-pc-windows-msvc]
+pkg-fmt = "zip"
@@ -0,0 +1,6 @@
+# https://github.com/sharkdp/fd/issues/1085
+[target.aarch64-unknown-linux-gnu.env]
+passthrough = ["JEMALLOC_SYS_WITH_LG_PAGE=16"]
+
+[target.aarch64-unknown-linux-musl.env]
+passthrough = ["JEMALLOC_SYS_WITH_LG_PAGE=16"]
@@ -1,15 +1,22 @@
-PROFILE=release
+PROFILE?=release
 EXE=target/$(PROFILE)/fd
 prefix=/usr/local
 bindir=$(prefix)/bin
 datadir=$(prefix)/share
 exe_name=fd
+ifdef VERSION
+	ARCHIVE_NAME = fd-v$(VERSION)
+else
+	ARCHIVE_NAME = fd
+endif
+export ARCHIVE_NAME
+archive_path=package/$(ARCHIVE_NAME).tar.gz

 $(EXE): Cargo.toml src/**/*.rs
-	cargo build --profile $(PROFILE)
+	cargo build --profile $(PROFILE) --locked

 .PHONY: completions
-completions: autocomplete/fd.bash autocomplete/fd.fish autocomplete/fd.ps1 autocomplete/_fd
+completions: autocomplete/fd.bash autocomplete/fd.fish autocomplete/_fd.ps1 autocomplete/_fd autocomplete/_fdfind autocomplete/fdfind.bash autocomplete/fdfind.fish

 comp_dir=@mkdir -p autocomplete

@@ -21,7 +28,7 @@ autocomplete/fd.fish: $(EXE)
 	$(comp_dir)
 	$(EXE) --gen-completions fish > $@

-autocomplete/fd.ps1: $(EXE)
+autocomplete/_fd.ps1: $(EXE)
 	$(comp_dir)
 	$(EXE) --gen-completions powershell > $@

@@ -29,9 +36,29 @@ autocomplete/_fd: contrib/completion/_fd
 	$(comp_dir)
 	cp $< $@

+autocomplete/_fdfind: contrib/completion/_fdfind
+	$(comp_dir)
+	cp $< $@
+
+autocomplete/fdfind.bash: contrib/completion/fdfind.bash
+	$(comp_dir)
+	cp $< $@
+
+autocomplete/fdfind.fish: contrib/completion/fdfind.fish
+	$(comp_dir)
+	cp $< $@
+
+archive: $(archive_path)
+
+$(archive_path): completions $(EXE)
+	bash scripts/create-archive.sh
+
 install: $(EXE) completions
 	install -Dm755 $(EXE) $(DESTDIR)$(bindir)/fd
 	install -Dm644 autocomplete/fd.bash $(DESTDIR)/$(datadir)/bash-completion/completions/$(exe_name)
 	install -Dm644 autocomplete/fd.fish $(DESTDIR)/$(datadir)/fish/vendor_completions.d/$(exe_name).fish
-	install -Dm644 autocomplete/_fd $(DESTDIR)/$(datadir)/zsh/site-functions/_$(exe_name)
+	install -Dm644 autocomplete/_fd $(DESTDIR)/$(datadir)/zsh/site-functions/_fd
+	install -Dm644 autocomplete/fdfind.bash $(DESTDIR)/$(datadir)/zsh/site-functions/fdfind.bash
+	install -Dm644 autocomplete/fdfind.fish $(DESTDIR)/$(datadir)/zsh/site-functions/fdfind.fish
+	install -Dm644 autocomplete/_fdfind $(DESTDIR)/$(datadir)/zsh/site-functions/_fdfind
 	install -Dm644 doc/fd.1 $(DESTDIR)/$(datadir)/man/man1/$(exe_name).1
@@ -10,10 +10,7 @@ It is a simple, fast and user-friendly alternative to [`find`](https://www.gnu.o
 While it does not aim to support all of `find`'s powerful functionality, it provides sensible
 (opinionated) defaults for a majority of use cases.

-Quick links:
-* [How to use](#how-to-use)
-* [Installation](#installation)
-* [Troubleshooting](#troubleshooting)
+[Installation](#installation) • [How to use](#how-to-use) • [Troubleshooting](#troubleshooting)

 ## Features

@@ -63,7 +60,7 @@ X11/xinit/xinitrc
 X11/xinit/xserverrc
 ```

-The regular expression syntax used by `fd` is [documented here](https://docs.rs/regex/1.0.0/regex/#syntax).
+The regular expression syntax used by `fd` is [documented here](https://docs.rs/regex/latest/regex/#syntax).

 ### Specifying the root directory

@@ -143,14 +140,14 @@ target/debug/deps/libnum_cpus-f5ce7ef99006aa05.rlib
 ```

 To really search *all* files and directories, simply combine the hidden and ignore features to show
-everything (`-HI`).
+everything (`-HI`) or use `-u`/`--unrestricted`.

 ### Matching the full path
 By default, *fd* only matches the filename of each file. However, using the `--full-path` or `-p` option,
 you can match against the full path.

 ```bash
-> fd -p -g '**/.git/config'
+> fd -u -p -g '**/.git/config'
 > fd -p '.*/lesson-\d+/[a-z]+.(jpg|png)'
 ```

@@ -179,6 +176,12 @@ fd -e h -e cpp -x clang-format -i
 Note how the `-i` option to `clang-format` can be passed as a separate argument. This is why
 we put the `-x` option last.

+Any positional arguments after `-x` belong to the command template, not to `fd` itself. If you
+also want to pass a pattern or search path, put `-x` last:
+``` bash
+fd pattern path -x echo
+```
+
 Find all `test_*.py` files and open them in your favorite editor:
 ``` bash
 fd -g 'test_*.py' -X vim
@@ -209,7 +212,7 @@ See below for more details on the placeholder syntax.
 The terminal output of commands run from parallel threads using `-x` will not be interlaced or garbled,
 so `fd -x` can be used to rudimentarily parallelize a task run over many files.
 An example of this is calculating the checksum of each individual file within a directory.
-```
+``` bash
 fd -tf -x md5sum > file_checksums.txt
 ```

@@ -218,6 +221,9 @@ fd -tf -x md5sum > file_checksums.txt
 The `-x` and `-X` options take a *command template* as a series of arguments (instead of a single string).
 If you want to add additional options to `fd` after the command template, you can terminate it with a `\;`.

+For example, `fd -x echo \; pattern path` treats `pattern path` as `fd` arguments instead of
+passing them to `echo`. In practice, it is often clearer to write `fd pattern path -x echo`.
+
 The syntax for generating commands is similar to that of [GNU Parallel](https://www.gnu.org/software/parallel/):

 - `{}`: A placeholder token that will be replaced with the path of the search result
@@ -261,12 +267,17 @@ To make exclude-patterns like these permanent, you can create a `.fdignore` file
 /mnt/external-drive
 *.bak
 ```
-Note: `fd` also supports `.ignore` files that are used by other programs such as `rg` or `ag`.
+
+> [!NOTE]
+> `fd` also supports `.ignore` files that are used by other programs such as `rg` or `ag`.

 If you want `fd` to ignore these patterns globally, you can put them in `fd`'s global ignore file.
 This is usually located in `~/.config/fd/ignore` in macOS or Linux, and `%APPDATA%\fd\ignore` in
 Windows.

+You may wish to include `.git/` in your `fd/ignore` file so that `.git` directories, and their contents
+are not included in output if you use the `--hidden` option.
+
 ### Deleting files

 You can use `fd` to remove all files and directories that are matched by your search pattern.
@@ -284,7 +295,8 @@ option:
 If you also want to remove a certain class of directories, you can use the same technique. You will
 have to use `rm`s `--recursive`/`-r` flag to remove directories.

-Note: there are scenarios where using `fd … -X rm -r` can cause race conditions: if you have a
+> [!NOTE]
+> There are scenarios where using `fd … -X rm -r` can cause race conditions: if you have a
 path like `…/foo/bar/foo/…` and want to remove all directories named `foo`, you can end up in a
 situation where the outer `foo` directory is removed first, leading to (harmless) *"'foo/bar/foo':
 No such file or directory"* errors in the `rm` call.
@@ -295,7 +307,7 @@ This is the output of `fd -h`. To see the full set of command-line options, use
 also includes a much more detailed help text.

 ```
-Usage: fd [OPTIONS] [pattern] [path]...
+Usage: fd [OPTIONS] [pattern [path]...]

 Arguments:
  [pattern]  the search pattern (a regular expression, unless '--glob' is used; optional)
@@ -312,82 +324,87 @@ Options:
  -L, --follow                     Follow symbolic links
  -p, --full-path                  Search full abs. path (default: filename only)
  -d, --max-depth <depth>          Set maximum search depth (default: none)
-  -E, --exclude <pattern>          Exclude entries that match the given glob pattern
-  -t, --type <filetype>            Filter by type: file (f), directory (d), symlink (l),
-                                   executable (x), empty (e), socket (s), pipe (p)
-  -e, --extension <ext>            Filter by file extension
+  -E, --exclude <glob>             Exclude entries that match the given glob pattern
+  -t, --type <filetype>            Filter by type: file (f), directory (d/dir), symlink (l),
+                                   executable (x), empty (e), socket (s), pipe (p), char-device
+                                   (c), block-device (b)
+  -e, --extension <ext>            Filter by extension
  -S, --size <size>                Limit results based on the size of files
      --changed-within <date|dur>  Filter by file modification time (newer than)
      --changed-before <date|dur>  Filter by file modification time (older than)
  -o, --owner <user:group>         Filter by owning user and/or group
+      --format <fmt>               Print results according to template
  -x, --exec <cmd>...              Execute a command for each search result
  -X, --exec-batch <cmd>...        Execute a command with all search results at once
  -c, --color <when>               When to use colors [default: auto] [possible values: auto,
                                   always, never]
+      --hyperlink[=<when>]         Add hyperlinks to output paths [default: never] [possible
+                                   values: auto, always, never]
+      --ignore-contain <name>      Ignore directories containing the named entry
  -h, --help                       Print help (see more with '--help')
  -V, --version                    Print version
 ```

+Note that options can be given after the pattern and/or path as well.
+
 ## Benchmark

-Let's search my home folder for files that end in `[0-9].jpg`. It contains ~190.000
-subdirectories and about a million files. For averaging and statistical analysis, I'm using
+Let's search my home folder for files that end in `[0-9].jpg`. It contains ~750,000
+subdirectories and about a 4 million files. For averaging and statistical analysis, I'm using
 [hyperfine](https://github.com/sharkdp/hyperfine). The following benchmarks are performed
 with a "warm"/pre-filled disk-cache (results for a "cold" disk-cache show the same trends).

 Let's start with `find`:
 ```
-Benchmark #1: find ~ -iregex '.*[0-9]\.jpg$'
-
-  Time (mean ± σ):      7.236 s ±  0.090 s
-
-  Range (min … max):    7.133 s …  7.385 s
+Benchmark 1: find ~ -iregex '.*[0-9]\.jpg$'
+  Time (mean ± σ):     19.922 s ±  0.109 s
+  Range (min … max):   19.765 s … 20.065 s
 ```

 `find` is much faster if it does not need to perform a regular-expression search:
 ```
-Benchmark #2: find ~ -iname '*[0-9].jpg'
-
-  Time (mean ± σ):      3.914 s ±  0.027 s
-
-  Range (min … max):    3.876 s …  3.964 s
+Benchmark 2: find ~ -iname '*[0-9].jpg'
+  Time (mean ± σ):     11.226 s ±  0.104 s
+  Range (min … max):   11.119 s … 11.466 s
 ```

-Now let's try the same for `fd`. Note that `fd` *always* performs a regular expression
-search. The options `--hidden` and `--no-ignore` are needed for a fair comparison,
-otherwise `fd` does not have to traverse hidden folders and ignored paths (see below):
+Now let's try the same for `fd`. Note that `fd` performs a regular expression
+search by default. The options `-u`/`--unrestricted` option is needed here for
+a fair comparison. Otherwise `fd` does not have to traverse hidden folders and
+ignored paths (see below):
 ```
-Benchmark #3: fd -HI '.*[0-9]\.jpg$' ~
-
-  Time (mean ± σ):     811.6 ms ±  26.9 ms
-
-  Range (min … max):   786.0 ms … 870.7 ms
+Benchmark 3: fd -u '[0-9]\.jpg$' ~
+  Time (mean ± σ):     854.8 ms ±  10.0 ms
+  Range (min … max):   839.2 ms … 868.9 ms
 ```
-For this particular example, `fd` is approximately nine times faster than `find -iregex`
-and about five times faster than `find -iname`. By the way, both tools found the exact
-same 20880 files :smile:.
+For this particular example, `fd` is approximately **23 times faster** than `find -iregex`
+and about **13 times faster** than `find -iname`. By the way, both tools found the exact
+same 546 files :smile:.

-Finally, let's run `fd` without `--hidden` and `--no-ignore` (this can lead to different
-search results, of course). If *fd* does not have to traverse the hidden and git-ignored
-folders, it is almost an order of magnitude faster:
-```
-Benchmark #4: fd '[0-9]\.jpg$' ~
-
-  Time (mean ± σ):     123.7 ms ±   6.0 ms
-
-  Range (min … max):   118.8 ms … 140.0 ms
-```
-
-**Note**: This is *one particular* benchmark on *one particular* machine. While I have
-performed quite a lot of different tests (and found consistent results), things might
-be different for you! I encourage everyone to try it out on their own. See
+**Note**: This is *one particular* benchmark on *one particular* machine. While we have
+performed a lot of different tests (and found consistent results), things might
+be different for you! We encourage everyone to try it out on their own. See
 [this repository](https://github.com/sharkdp/fd-benchmarks) for all necessary scripts.

-Concerning *fd*'s speed, the main credit goes to the `regex` and `ignore` crates that are also used
-in [ripgrep](https://github.com/BurntSushi/ripgrep) (check it out!).
+Concerning *fd*'s speed, a lot of credit goes to the `regex` and `ignore` crates that are
+also used in [ripgrep](https://github.com/BurntSushi/ripgrep) (check it out!).

 ## Troubleshooting

+### `fd` does not find my file!
+
+Remember that `fd` ignores hidden directories and files by default. It also ignores patterns
+from `.gitignore` files. If you want to make sure to find absolutely every possible file, always
+use the options `-u`/`--unrestricted` option (or `-HI` to enable hidden and ignored files):
+``` bash
+> fd -u …
+```
+
+Also remember that by default, `fd` only searches based on the filename and
+doesn't compare the pattern to the full path. If you want to search based on the
+full path (similar to the `-path` option of `find`) you need to use the `--full-path`
+(or `-p`) option.
+
 ### Colorized output

 `fd` can colorize files by extension, just like `ls`. In order for this to work, the environment
@@ -401,15 +418,6 @@ for alternative, more complete (or more colorful) variants, see [here](https://g

 `fd` also honors the [`NO_COLOR`](https://no-color.org/) environment variable.

-### `fd` does not find my file!
-
-Remember that `fd` ignores hidden directories and files by default. It also ignores patterns
-from `.gitignore` files. If you want to make sure to find absolutely every possible file, always
-use the options `-H` and `-I` to disable these two features:
-``` bash
-> fd -HI …
-```
-
 ### `fd` doesn't seem to interpret my regex pattern correctly

 A lot of special regex characters (like `[]`, `^`, `$`, ..) are also special characters in your
@@ -436,6 +444,11 @@ you can use `export -f my_function` to make available to child processes. You wo
 need to call `fd -x bash -c 'my_function "$1"' bash`. For other use cases or shells, use
 a (temporary) shell script.

+### Placeholders in `-x`/`-X`
+
+Depending on your shell, you may need to quote the placeholders (`{}`, `{/}`, `{//}`,
+`{.}`, `{/.}`) to prevent the shell from interpreting them before `fd` sees them.
+
 ## Integration with other programs

 ### Using fd with `fzf`
@@ -532,7 +545,7 @@ newlines). In the same way, the `-0` option of `xargs` tells it to read the inpu
 If you run Ubuntu 19.04 (Disco Dingo) or newer, you can install the
 [officially maintained package](https://packages.ubuntu.com/fd-find):
 ```
-sudo apt install fd-find
+apt install fd-find
 ```
 Note that the binary is called `fdfind` as the binary name `fd` is already used by another package.
 It is recommended that after installation, you add a link to `fd` by executing command
@@ -542,21 +555,25 @@ Make sure that `$HOME/.local/bin` is in your `$PATH`.
 If you use an older version of Ubuntu, you can download the latest `.deb` package from the
 [release page](https://github.com/sharkdp/fd/releases) and install it via:
 ``` bash
-sudo dpkg -i fd_8.7.1_amd64.deb # adapt version number and architecture
+dpkg -i fd_9.0.0_amd64.deb # adapt version number and architecture
 ```

+Note that the .deb packages on the release page for this project still name the executable `fd`.
+
 ### On Debian

 If you run Debian Buster or newer, you can install the
 [officially maintained Debian package](https://tracker.debian.org/pkg/rust-fd-find):
 ```
-sudo apt-get install fd-find
+apt-get install fd-find
 ```
 Note that the binary is called `fdfind` as the binary name `fd` is already used by another package.
 It is recommended that after installation, you add a link to `fd` by executing command
 `ln -s $(which fdfind) ~/.local/bin/fd`, in order to use `fd` in the same way as in this documentation.
 Make sure that `$HOME/.local/bin` is in your `$PATH`.

+Note that the .deb packages on the release page for this project still name the executable `fd`.
+
 ### On Fedora

 Starting with Fedora 28, you can install `fd` from the official package sources:
@@ -574,10 +591,12 @@ apk add fd

 ### On Arch Linux

-You can install [the fd package](https://www.archlinux.org/packages/community/x86_64/fd/) from the official repos:
+You can install [the fd package](https://www.archlinux.org/packages/extra/x86_64/fd/) from the official repos:
 ```
 pacman -S fd
 ```
+You can also install fd [from the AUR](https://aur.archlinux.org/packages/fd-git).
+
 ### On Gentoo Linux

 You can use [the fd ebuild](https://packages.gentoo.org/packages/sys-apps/fd) from the official repo:
@@ -599,7 +618,21 @@ You can install `fd` via xbps-install:
 xbps-install -S fd
 ```

-### On RedHat Enterprise Linux 8 (RHEL8), Almalinux 8, EuroLinux 8 or Rocky Linux 8
+### On ALT Linux
+
+You can install [the fd package](https://packages.altlinux.org/en/sisyphus/srpms/fd/) from the official repo:
+```
+apt-get install fd
+```
+
+### On Solus
+
+You can install [the fd package](https://github.com/getsolus/packages/tree/main/packages/f/fd) from the official repo:
+```
+eopkg install fd
+```
+
+### On RedHat Enterprise Linux (RHEL) 8/9/10, Almalinux 8/9/10, EuroLinux 8/9 or Rocky Linux 8/9/10

 You can install [the `fd` package](https://copr.fedorainfracloud.org/coprs/tkbcopr/fd/) from Fedora Copr.

@@ -608,7 +641,7 @@ dnf copr enable tkbcopr/fd
 dnf install fd
 ```

-A different version using the [slower](https://github.com/sharkdp/fd/pull/481#issuecomment-534494592) malloc [instead of jemalloc](https://bugzilla.redhat.com/show_bug.cgi?id=2216193#c1) is also available from the EPEL8 repo.
+A different version using the [slower](https://github.com/sharkdp/fd/pull/481#issuecomment-534494592) malloc [instead of jemalloc](https://bugzilla.redhat.com/show_bug.cgi?id=2216193#c1) is also available from the EPEL8/9 repo as the package `fd-find`.

 ### On macOS

@@ -619,7 +652,7 @@ brew install fd

 … or with MacPorts:
 ```
-sudo port install fd
+port install fd
 ```

 ### On Windows
@@ -648,6 +681,13 @@ You can install [the fd package](https://guix.gnu.org/en/packages/fd-8.1.1/) fro
 guix install fd
 ```

+### On Mise
+
+You can use [mise](https://github.com/jdx/mise) to install `fd` with a command like this:
+```
+mise use -g fd@latest
+```
+
 ### On NixOS / via Nix

 You can use the [Nix package manager](https://nixos.org/nix/) to install `fd`:
@@ -655,6 +695,13 @@ You can use the [Nix package manager](https://nixos.org/nix/) to install `fd`:
 nix-env -i fd
 ```

+### Via Flox
+
+You can use [Flox](https://flox.dev) to install `fd` into a Flox environment:
+```
+flox install fd
+```
+
 ### On FreeBSD

 You can install [the fd-find package](https://www.freshports.org/sysutils/fd) from the official repo:
@@ -664,7 +711,7 @@ pkg install fd-find

 ### From npm

-On linux and macOS, you can install the [fd-find](https://npm.im/fd-find) package:
+On Linux and macOS, you can install the [fd-find](https://npm.im/fd-find) package:

 ```
 npm install -g fd-find
@@ -676,7 +723,7 @@ With Rust's package manager [cargo](https://github.com/rust-lang/cargo), you can
 ```
 cargo install fd-find
 ```
-Note that rust version *1.64.0* or later is required.
+Note that rust version *1.90.0* or later is required.

 `make` is also needed for the build.

@@ -699,6 +746,37 @@ cargo test
 cargo install --path .
 ```

+### Completions
+
+#### From Release Archives
+
+Pre-built completion files are included in the release archives (`.tar.gz`/`.zip`) on the
+[Releases page](https://github.com/sharkdp/fd/releases), in the `autocomplete` directory.
+To use these completions:
+
+- **bash**: Source the `fd.bash` file in your `~/.bashrc`, or place it in a directory that gets sourced automatically.
+- **zsh**: Move `_fd` to a directory in your `fpath` (e.g., `~/.zfunc`).
+- **fish**: Copy `fd.fish` to `~/.config/fish/completions/`.
+- **powershell**: Source `_fd.ps1` from one of your [profile scripts](https://learn.microsoft.com/en-us/powershell/scripting/learn/shell/creating-profiles?view=powershell-7.5).
+
+#### Generate from fd
+
+You can also generate completions directly using `fd --gen-completions <shell>`:
+
+```bash
+# Bash
+fd --gen-completions bash > ~/.local/share/bash-completion/completions/fd
+
+# Zsh (ensure ~/.zfunc is in your fpath)
+fd --gen-completions zsh > ~/.zfunc/_fd
+
+# Fish
+fd --gen-completions fish > ~/.config/fish/completions/fd.fish
+
+# PowerShell
+fd --gen-completions powershell >> $PROFILE
+```
+
 ## Maintainers

 - [sharkdp](https://github.com/sharkdp)
@@ -707,8 +785,6 @@ cargo install --path .

 ## License

-Copyright (c) 2017-2021 The fd developers
-
 `fd` is distributed under the terms of both the MIT License and the Apache License 2.0.

 See the [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT) files for license details.
@@ -0,0 +1,33 @@
+# Security Reporting
+
+If you wish to report a security vulnerability privately, we appreciate your diligence. Please follow the guidelines below to submit your report.
+
+## Reporting
+
+To report a security vulnerability, please provide the following information:
+
+1. **PROJECT**
+   - Include the URL of the project repository - Example: <https://github.com/sharkdp/fd>
+
+2. **PUBLIC**
+   - Indicate whether this vulnerability has already been publicly discussed or disclosed.
+   - If so, provide relevant links.
+
+3. **DESCRIPTION**
+   - Provide a detailed description of the security vulnerability.
+   - Include as much information as possible to help us understand and address the issue.
+
+Send this information, along with any additional relevant details, to our [vulnerability reporting form](https://github.com/sharkdp/fd/security/advisories/new).
+
+## Confidentiality
+
+We kindly ask you to keep the report confidential until a public announcement is made.
+
+## Notes
+
+- Vulnerabilities will be handled on a best-effort basis.
+- You may request an advance copy of the patched release, but we cannot guarantee early access before the public release.
+- You will be notified via email simultaneously with the public announcement.
+- We will respond within a few weeks to confirm whether your report has been accepted or rejected.
+
+Thank you for helping to improve the security of our project!
@@ -1,12 +0,0 @@
-fn main() {
-    let min_version = "1.64";
-
-    match version_check::is_min_version(min_version) {
-        Some(true) => {}
-        // rustc version too small or can't figure it out
-        _ => {
-            eprintln!("'fd' requires rustc >= {}", min_version);
-            std::process::exit(1);
-        }
-    }
-}
@@ -26,6 +26,8 @@ _fd() {
    {l,symlink}'\:"symbolic links"'
    {e,empty}'\:"empty files or directories"'
    {x,executable}'\:"executable (files)"'
+    {b,block-device}'\:"block devices"'
+    {c,char-device}'\:"character devices"'
    {s,socket}'\:"sockets"'
    {p,pipe}'\:"named pipes (FIFOs)"'
  )
@@ -137,6 +139,8 @@ _fd() {
      always\:"always use colorized output"
    ))'

+    '--hyperlink=-[add hyperlinks to output paths]::when:(auto never always)'
+
    + '(threads)'
    {-j+,--threads=}'[set the number of threads for searching and executing]:number of threads'

@@ -160,7 +164,7 @@ _fd() {
    $no'(*)*--search-path=[set search path (instead of positional <path> arguments)]:directory:_files -/'

    + strip-cwd-prefix
-    $no'(strip-cwd-prefix exec-cmds)--strip-cwd-prefix[Strip ./ prefix when output is redirected]'
+    $no'(strip-cwd-prefix exec-cmds)--strip-cwd-prefix=-[When to strip ./]::when:(always never auto)'

    + and
    '--and=[additional required search path]:pattern'
@@ -0,0 +1,2 @@
+#compdef fdfind
+_fd "$@"
@@ -0,0 +1,8 @@
+# Source fd completions
+source /usr/share/bash-completion/completions/fd
+
+if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
+  complete -F _fd -o nosort -o bashdefault -o default fdfind
+else
+  complete -F _fd -o bashdefault -o default fdfind
+fi
@@ -0,0 +1 @@
+complete -c fdfind --wraps fd
@@ -18,8 +18,8 @@ fd \- find entries in the filesystem
 .IR num ]
 .RB [ \-x
 .IR cmd ]
-.RI [ pattern ]
-.RI [ path... ]
+.RI [ pattern
+.RI [ path... ]]
 .SH DESCRIPTION
 .B fd
 is a simple, fast and user-friendly alternative to
@@ -29,11 +29,25 @@ By default
 .B fd
 uses regular expressions for the pattern. However, this can be changed to use simple glob patterns
 with the '\-\-glob' option.
+.P
+By default
+.B fd
+will exclude hidden files and directories, as well as any files that match gitignore rules
+or ignore rules in .ignore or .fdignore files.
+.P
+If you wish to search all files in a specific directory, you can use '' or . as the search pattern,
+to match all files. Or you can use the '\-\-search\-path' option to specify the path(s) instead of
+the positional parameter.
+.P
+Options may be given anywhere on the command line.
 .SH OPTIONS
 .TP
 .B \-H, \-\-hidden
 Include hidden files and directories in the search results
 (default: hidden files and directories are skipped). The flag can be overridden with '--no-hidden'.
+.IP
+Ignored files are still excluded unless \-\-no\-ignore or \-\-no\-ignore\-vcs
+is also used.
 .TP
 .B \-I, \-\-no\-ignore
 Show search results from files and directories that would otherwise be ignored by
@@ -100,7 +114,14 @@ Perform a regular-expression based search (default). This can be used to overrid
 .TP
 .B \-F, \-\-fixed\-strings
 Treat the pattern as a literal string instead of a regular expression. Note that this also
-performs substring comparison. If you want to match on an exact filename, consider using '\-\-glob'.
+performs substring comparison. If you want to match on an exact filename, consider using '\-\-glob'
+or '\-\-exact'.
+.TP
+.B \-\-exact
+Perform an exact match. This is equivalent to '\-\-fixed\-strings' but requires the pattern to
+match the entire filename (or the full path if '\-\-full\-path' is used), rather than a substring.
+Special regex characters in the pattern are treated as literal characters.
+Cannot be used together with '\-\-glob' or '\-\-fixed\-strings'.
 .TP
 .BI "\-\-and " pattern
 Add additional required search patterns, all of which must be matched. Multiple additional
@@ -148,9 +169,20 @@ can be used as an alias.
 Enable the display of filesystem errors for situations such as insufficient
 permissions or dead symlinks.
 .TP
-.B \-\-strip-cwd-prefix
-By default, relative paths are prefixed with './' when the output goes to a non interactive terminal
-(TTY). Use this flag to disable this behaviour.
+.B \-\-strip-cwd-prefix [when]
+By default, relative paths are prefixed with './' when -x/--exec,
+-X/--exec-batch, or -0/--print0 are given, to reduce the risk of a
+path starting with '-' being treated as a command line option. Use
+this flag to change this behavior. If this flag is used without a value,
+it is equivalent to passing "always". Possible values are:
+.RS
+.IP never
+Never strip the ./ at the beginning of paths
+.IP always
+Always strip the ./ at the beginning of paths
+.IP auto
+Only strip if used with --exec, --exec-batch, or --print0. That is, it resets to the default behavior.
+.RE
 .TP
 .B \-\-one\-file\-system, \-\-mount, \-\-xdev
 By default, fd will traverse the file system tree as far as other options dictate. With this flag, fd ensures that it does not descend into a different file system than the one it started in. Comparable to the -mount or -xdev filters of find(1).
@@ -180,10 +212,14 @@ Filter search by type:
 .RS
 .IP "f, file"
 regular files
-.IP "d, directory"
+.IP "d, dir, directory"
 directories
 .IP "l, symlink"
 symbolic links
+.IP "b, block-device"
+block devices
+.IP "c, char-device"
+character devices
 .IP "s, socket"
 sockets
 .IP "p, pipe"
@@ -221,14 +257,16 @@ Examples:
 .RE
 .TP
 .BI "\-e, \-\-extension " ext
-Filter search results by file extension
+Filter search results by extension
 .IR ext .
-This option can be used repeatedly to allow for multiple possible file extensions.
+This option can be used repeatedly to allow for multiple possible extensions.
+By default, extension filters apply to both files and directories. Use
+\fB\-\-type\fR to restrict the search to specific types.

 If you want to search for files without extension, you can use the regex '^[^.]+$'
 as a normal search pattern.
 .TP
-.BI "\-E, \-\-exclude " pattern
+.BI "\-E, \-\-exclude " glob
 Exclude files/directories that match the given glob pattern.
 This overrides any other ignore logic.
 Multiple exclude patterns can be specified.
@@ -236,6 +274,10 @@ Examples:
  \-\-exclude '*.pyc'
  \-\-exclude node_modules
 .TP
+.BI "\-\-ignore-contain " name
+Exclude directories that (directly) contain the given name.
+This option can be specified multiple times.
+.TP
 .BI "\-\-ignore-file " path
 Add a custom ignore-file in '.gitignore' format.
 These files have a low precedence.
@@ -253,6 +295,24 @@ Do not colorize output.
 Always colorize output.
 .RE
 .TP
+.B "\-\-hyperlink
+Specify whether the output should use terminal escape codes to indicate a hyperlink to a
+file url pointing to the path.
+
+The value can be auto, always, or never.
+
+Currently, the default is "never", and if the option is used without an argument "auto" is
+used. In the future this may be changed to "auto" and "always".
+.RS
+.IP auto
+Only output hyperlinks if color is also enabled, as a proxy for whether terminal escape
+codes are acceptable.
+.IP never
+Never output hyperlink escapes.
+.IP always
+Always output hyperlink escapes, regardless of color settings.
+.RE
+.TP
 .BI "\-j, \-\-threads " num
 Set number of threads to use for searching & executing (default: number of available CPU cores).
 .TP
@@ -295,10 +355,11 @@ tebibytes
 .TP
 .BI "\-\-changed-within " date|duration
 Filter results based on the file modification time.
-Files with modification times greater than the argument will be returned.
+Files with modification timestamps greater than the argument will be returned.
 The argument can be provided as a duration (\fI10h, 1d, 35min\fR) or as a specific point
-in time in either full RFC3339 format with time zone, or as a date or datetime in the
-local time zone (\fIYYYY-MM-DD\fR or \fIYYYY-MM-DD HH:MM:SS\fR).
+in time as full RFC3339 format with time zone, as a date or datetime in the
+local time zone (\fIYYYY-MM-DD\fR or \fIYYYY-MM-DD HH:MM:SS\fR), or as the prefix '@'
+followed by the number of seconds since the Unix epoch (@[0-9]+).
 \fB\-\-change-newer-than\fR,
 .B --newer
 or
@@ -309,13 +370,15 @@ Examples:
  \-\-changed-within 2weeks
  \-\-change-newer-than "2018-10-27 10:00:00"
  \-\-newer 2018-10-27
+  \-\-changed-after @1704067200
 .TP
 .BI "\-\-changed-before " date|duration
 Filter results based on the file modification time.
-Files with modification times less than the argument will be returned.
+Files with modification timestamps less than the argument will be returned.
 The argument can be provided as a duration (\fI10h, 1d, 35min\fR) or as a specific point
-in time in either full RFC3339 format with time zone, or as a date or datetime in the
-local time zone (\fIYYYY-MM-DD\fR or \fIYYYY-MM-DD HH:MM:SS\fR).
+in time as full RFC3339 format with time zone, as a date or datetime in the
+local time zone (\fIYYYY-MM-DD\fR or \fIYYYY-MM-DD HH:MM:SS\fR), or as the prefix '@'
+followed by the number of seconds since the Unix epoch (@[0-9]+).
 .B --change-older-than
 or
 .B --older
@@ -324,6 +387,7 @@ can be used as aliases.
 Examples:
  \-\-changed-before "2018-10-27 10:00:00"
  \-\-change-older-than 2weeks
+  \-\-older @1704067200
 .TP
 .BI "-o, \-\-owner " [user][:group]
 Filter files by their user and/or group. Format: [(user|uid)][:(group|gid)]. Either side
@@ -334,7 +398,7 @@ Examples:
  \-\-owner :students
  \-\-owner "!john:students"
 .TP
-.BI "\-\-base\-directory " path
+.BI "-C, \-\-base\-directory " path
 Change the current working directory of fd to the provided path. This means that search results will
 be shown with respect to the given base path. Note that relative paths which are passed to fd via the
 positional \fIpath\fR argument or the \fB\-\-search\-path\fR option will also be resolved relative to
@@ -348,6 +412,30 @@ Set the path separator to use when printing file paths. The default is the OS-sp
 Provide paths to search as an alternative to the positional \fIpath\fR argument. Changes the usage to
 \'fd [FLAGS/OPTIONS] \-\-search\-path PATH \-\-search\-path PATH2 [PATTERN]\'
 .TP
+.BI "\-\-format " fmt
+Specify a template string that is used for printing a line for each file found.
+
+The following placeholders are substituted into the string for each file before printing:
+.RS
+.IP {}
+path (of the current search result)
+.IP {/}
+basename
+.IP {//}
+parent directory
+.IP {.}
+path without file extension
+.IP {/.}
+basename without file extension
+.IP {{
+literal '{' (an escape sequence)
+.IP }}
+literal '}' (an escape sequence)
+.P
+Notice that you can use "{{" and "}}" to escape "{" and "}" respectively, which is especially
+useful if you need to include the literal text of one of the above placeholders.
+.RE
+.TP
 .BI "\-x, \-\-exec " command
 .RS
 Execute
@@ -364,22 +452,19 @@ This option can be specified multiple times, in which case all commands are run
 file found, in the order they are provided. In that case, you must supply a ';' argument for
 all but the last commands.

-The following placeholders are substituted before the command is executed:
-.RS
-.IP {}
-path (of the current search result)
-.IP {/}
-basename
-.IP {//}
-parent directory
-.IP {.}
-path without file extension
-.IP {/.}
-basename without file extension
-.RE
+If parallelism is enabled, the order commands will be executed in is non-deterministic. And even with
+--threads=1, the order is determined by the operating system and may not be what you expect. Thus, it is
+recommended that you don't rely on any ordering of the results.
+
+Before executing the command, any placeholder patterns in the command are replaced with the
+corresponding values for the current file. The same placeholders are used as in the "\-\-format"
+option.

 If no placeholder is present, an implicit "{}" at the end is assumed.

+If --print0 is also given, then a null character (\\0) will be printed between the output for each found entry.
+This allows another program to easily distinguish the output for each file if the command(s) produce multiple lines.
+
 Examples:

  - find all *.zip files and unzip them:
@@ -393,6 +478,10 @@ Examples:
  - Convert all *.jpg files to *.png files:

        fd -e jpg -x convert {} {.}.png
+
+  - Run stat for each *.txt file, separated by null characters
+
+        fd -0 -e txt -x stat
 .RE
 .TP
 .BI "\-X, \-\-exec-batch " command
@@ -400,22 +489,19 @@ Examples:
 Execute
 .I command
 once, with all search results as arguments.
-One of the following placeholders is substituted before the command is executed:
-.RS
-.IP {}
-path (of all search results)
-.IP {/}
-basename
-.IP {//}
-parent directory
-.IP {.}
-path without file extension
-.IP {/.}
-basename without file extension
-.RE
+
+The order of the arguments is non-deterministic and should not be relied upon.
+
+This uses the same placeholders as "\-\-format" and "\-\-exec", but instead of expanding
+once per command invocation each argument containing a placeholder is expanding for every
+file in a batch and passed as separate arguments.

 If no placeholder is present, an implicit "{}" at the end is assumed.

+Like \-\-exec, subsequent arguments are assumed to be part of
+.I command
+until either the end of command arguments or a ';' argument. See above.
+
 Like \-\-exec, this can be used multiple times, in which case each command will be run in
 the order given.

@@ -461,6 +547,17 @@ is set, use
 .IR $XDG_CONFIG_HOME/fd/ignore .
 Otherwise, use
 .IR $HOME/.config/fd/ignore .
+.SH FILES
+.TP
+.B .fdignore
+This file works similarly to a .gitignore file anywhere in the searched tree and specifies patterns
+that should be excluded from the search. However, this file is specific to fd, and will be used even
+if the --no-ignore-vcs option is used.
+.TP
+.B $XDG_CONFIG_HOME/fd/ignore
+Global ignore file. Unless ignore mode is turned off (such as with --no-ignore)
+ignore entries in this file will be ignored, as if it was an .fdignore file in the
+current directory.
 .SH EXAMPLES
 .TP
 .RI "Find files and directories that match the pattern '" needle "':"
@@ -474,6 +571,16 @@ $ fd -e py
 .TP
 .RI "Open all search results with vim:"
 $ fd pattern -X vim
+.SH Tips and Tricks
+.IP \[bu]
+If you add ".git/" to your global ignore file ($XDG_CONFIG_HOME/fd/ignore), then
+".git" folders will be ignored by default, even when the --hidden option is used.
+.IP \[bu]
+You can use a shell alias or a wrapper script in order to pass desired flags to fd
+by default. For example if you do not like the default behavior of respecting gitignore,
+you can use
+`alias fd="/usr/bin/fd --no-ignore-vcs"`
+in your .bashrc to create an alias for fd that doesn't ignore git files by default.
 .SH BUGS
 Bugs can be reported on GitHub: https://github.com/sharkdp/fd/issues
 .SH SEE ALSO
@@ -5,11 +5,14 @@ necessary changes for the upcoming release.

 ## Version bump

+This section can be done by running `scripts/version-bump.sh` with the new version
+as an argument.
+
 - [ ] Create a new branch for the required changes for this release.
 - [ ] Update version in `Cargo.toml`. Run `cargo build` to update `Cargo.lock`.
      Make sure to `git add` the `Cargo.lock` changes as well.
 - [ ] Find the current min. supported Rust version by running
-      `grep '^\s*MIN_SUPPORTED_RUST_VERSION' .github/workflows/CICD.yml`.
+      `grep rust-version Cargo.toml`.
 - [ ] Update the `fd` version and the min. supported Rust version in `README.md`.
 - [ ] Update `CHANGELOG.md`. Change the heading of the *"Upcoming release"* section
      to the version of this release.
@@ -21,7 +24,7 @@ necessary changes for the upcoming release.
      new version).
 - [ ] Review `-h`, `--help`, and the `man` page.
 - [ ] Run `fd -h` and copy the output to the *"Command-line options"* section in
-      the README
+      the README. This can be done by running `gawk -i inplace -f scripts/update-help.awk README.md`.
 - [ ] Push all changes and wait for CI to succeed (before continuing with the
      next section).
 - [ ] Optional: manually test the new features and command-line options described
@@ -0,0 +1,12 @@
+## Sponsors
+
+`fd` development is sponsored by many individuals and companies. Thank you very much!
+
+Please note, that being sponsored does not affect the individuality of the `fd`
+project or affect the maintainers' actions in any way.
+We remain impartial and continue to assess pull requests solely on merit - the
+features added, bugs solved, and effect on the overall complexity of the code.
+No issue will have a different priority based on sponsorship status of the
+reporter.
+
+Contributions from anybody are most welcomed, please see our [`CONTRIBUTING.md`](../CONTRIBUTING.md) guide.
@@ -0,0 +1,67 @@
+#!/bin/bash
+#
+# Create a .tar.gz archive of the fd project for distribution
+#
+# Expected environment variables:
+#
+# TARGET: rust target to publish. Defaults to default rustc target
+# BIN_PATH: path to fd binary
+# PKG_STAGING: directory to use for staging files to include in the archive
+# ARCHIVE_NAME: Name of output file, minus extension, defaults to "fd" with a version appended
+#   if VERSION is specified
+# VERSION: version to publish
+# GITHUB_OUTPUT: file to store github output variables in
+
+if [[ -z "$TARGET" ]]; then
+  TARGET="$(rustc -vV | sed -n 's/host: //p')"
+fi
+
+PKG_suffix=".tar.gz"
+EXE_suffix=""
+case ${TARGET} in
+*-pc-windows-*)
+  PKG_suffix=".zip"
+  EXE_suffix=".exe"
+  ;;
+esac
+
+if [[ -z $BIN_PATH ]]; then
+  BIN_PATH=target/${PROFILE:-release}/fd
+fi
+
+if [[ -z "$ARCHIVE_NAME" ]]; then
+  ARCHIVE_NAME=fd
+  [[ -n "$VERSION" ]] && ARCHIVE_NAME+="-v$VERSION"
+fi
+
+PKG_NAME=${ARCHIVE_NAME}${PKG_suffix}
+
+staging_dir="${PKG_STAGING:-package}"
+ARCHIVE_DIR="${staging_dir}/${ARCHIVE_NAME}/"
+mkdir -p "${ARCHIVE_DIR}"
+
+# Binary
+cp "${BIN_PATH}" "$ARCHIVE_DIR"
+
+# README, LICENSE and CHANGELOG files
+cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "CHANGELOG.md" "$ARCHIVE_DIR"
+
+# Man page
+cp "doc/fd.1" "$ARCHIVE_DIR"
+
+# Autocompletion files
+cp -r autocomplete "${ARCHIVE_DIR}"
+
+# base compressed package
+pushd "${staging_dir}/" >/dev/null
+case ${TARGET} in
+*-pc-windows-*) 7z -y a "${PKG_NAME}" "${ARCHIVE_NAME}"/* | tail -2 ;;
+*) tar czf "${PKG_NAME}" "${ARCHIVE_NAME}"/* ;;
+esac;
+popd >/dev/null
+
+if [[ -n "$GITHUB_OUTPUT" ]]; then
+  echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT
+  # Let subsequent steps know where to find the compressed package
+  echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT
+fi
@@ -0,0 +1,135 @@
+#!/bin/bash
+COPYRIGHT_YEARS="2018 - "$(date "+%Y")
+MAINTAINER="David Peter <mail@david-peter.de>"
+REPO="https://github.com/sharkdp/fd"
+DPKG_STAGING="${CICD_INTERMEDIATES_DIR:-.}/debian-package"
+DPKG_DIR="${DPKG_STAGING}/dpkg"
+mkdir -p "${DPKG_DIR}"
+
+if [[ -z "$TARGET" ]]; then
+  TARGET="$(rustc -vV | sed -n 's|host: \(.*\)|\1|p')"
+fi
+
+case "$TARGET" in
+  *-musl*)
+    DPKG_BASENAME=fd-musl
+    DPKG_CONFLICTS="fd, fd-find"
+    ;;
+  *)
+    DPKG_BASENAME=fd
+    DPKG_CONFLICTS="fd-musl, fd-find"
+    ;;
+esac
+
+if [[ -z "$DPKG_VERSION" ]]; then
+  DPKG_VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r .packages[0].version)
+fi
+
+unset DPKG_ARCH
+case "${TARGET}" in
+  aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
+  arm-*-linux-*hf) DPKG_ARCH=armhf ;;
+  i686-*-linux-*) DPKG_ARCH=i686 ;;
+  x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
+  *) DPKG_ARCH=notset ;;
+esac;
+
+DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
+
+BIN_PATH=${BIN_PATH:-target/${TARGET}/release/fd}
+
+# Binary
+install -Dm755 "${BIN_PATH}" "${DPKG_DIR}/usr/bin/fd"
+
+# Man page
+install -Dm644 'doc/fd.1' "${DPKG_DIR}/usr/share/man/man1/fd.1"
+gzip -n --best "${DPKG_DIR}/usr/share/man/man1/fd.1"
+
+# Autocompletion files
+install -Dm644 'autocomplete/fd.bash' "${DPKG_DIR}/usr/share/bash-completion/completions/fd"
+install -Dm644 'autocomplete/fd.fish' "${DPKG_DIR}/usr/share/fish/vendor_completions.d/fd.fish"
+install -Dm644 'autocomplete/_fd' "${DPKG_DIR}/usr/share/zsh/vendor-completions/_fd"
+
+# README and LICENSE
+install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
+install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-MIT"
+install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-APACHE"
+install -Dm644 "CHANGELOG.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
+gzip -n --best "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
+
+# Create symlink and completions so fdfind can be used as well:
+ln -s "/usr/bin/fd" "${DPKG_DIR}/usr/bin/fdfind"
+
+install -Dm644 'autocomplete/fdfind.bash' "${DPKG_DIR}/usr/share/bash-completion/completions/fdfind"
+install -Dm644 'autocomplete/fdfind.fish' "${DPKG_DIR}/usr/share/fish/vendor_completions.d/fdfind.fish"
+install -Dm644 'autocomplete/_fdfind' "${DPKG_DIR}/usr/share/zsh/vendor-completions/_fdfind"
+
+cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: fd
+Source: ${REPO}
+
+Files: *
+Copyright: ${MAINTAINER}
+Copyright: $COPYRIGHT_YEARS ${MAINTAINER}
+License: Apache-2.0 or MIT
+
+License: Apache-2.0
+  On Debian systems, the complete text of the Apache-2.0 can be found in the
+  file /usr/share/common-licenses/Apache-2.0.
+
+License: MIT
+  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 the
+  Software without restriction, including without
+  limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of
+  the Software, and to permit persons to whom the Software
+  is furnished to do so, subject to the following
+  conditions:
+  .
+  The above copyright notice and this permission notice
+  shall be included in all copies or substantial portions
+  of the Software.
+  .
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+  ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+  TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+  SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+  IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+  DEALINGS IN THE SOFTWARE.
+EOF
+  chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"
+
+  # control file
+  mkdir -p "${DPKG_DIR}/DEBIAN"
+  cat > "${DPKG_DIR}/DEBIAN/control" <<EOF
+Package: ${DPKG_BASENAME}
+Version: ${DPKG_VERSION}
+Section: utils
+Priority: optional
+Maintainer: ${MAINTAINER}
+Homepage: ${REPO}
+Architecture: ${DPKG_ARCH}
+Provides: fd
+Conflicts: ${DPKG_CONFLICTS}
+Description: simple, fast and user-friendly alternative to find
+  fd is a program to find entries in your filesystem.
+  It is a simple, fast and user-friendly alternative to find.
+  While it does not aim to support all of finds powerful functionality, it provides
+  sensible (opinionated) defaults for a majority of use cases.
+EOF
+
+DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
+
+if [[ -n $GITHUB_OUTPUT ]]; then
+  echo "DPKG_NAME=${DPKG_NAME}" >> "$GITHUB_OUTPUT"
+  echo "DPKG_PATH=${DPKG_PATH}" >> "$GITHUB_OUTPUT"
+fi
+
+# build dpkg
+fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"
@@ -0,0 +1,41 @@
+#!/usr/bin/gawk -f
+
+BEGIN {
+  inSection = 0
+  inBlock = 0
+}
+
+
+/Command-line options/ { inSection=1 }
+
+inSection && /^```/ {
+  inBlock=1
+  inSection=0
+  # print the starting fence then move to next line
+  print
+  next
+}
+
+inBlock && /^```/ {
+  cmd="cargo run --release --quiet -- -h"
+  # Output the results of fd -h
+  u=0
+  while (cmd | getline line) {
+    # Skip everything before the usage line
+    if (line ~ /^Usage/) {
+      u=1;
+    }
+    if (u) {
+      print line
+    }
+  }
+  status = close(cmd)
+  if (status) {
+    print "failed to generate help output" > "/dev/stderr"
+    exit 1
+  }
+  inBlock = 0
+}
+
+!inBlock
+
@@ -0,0 +1,22 @@
+#!/usr/bin/bash
+
+set -eu
+
+# This script automates the "Version bump" section
+
+version="$1"
+
+if [[ -z $version ]]; then
+  echo "Usage: must supply version as first argument" >&2
+  exit 1
+fi
+
+git switch -C "release-$version"
+sed -i -e "0,/^\[badges/{s/^version =.*/version = \"$version\"/}" Cargo.toml
+
+msrv="$(grep -F rust-version Cargo.toml | sed -e 's/^rust-version= "\(.*\)"/\1/')"
+
+sed -i -e "s/Note that rust version \*[0-9.]+\* or later/Note that rust version *$msrv* or later/" README.md
+
+sed -i -e "s/^# Upcoming release/# $version/" CHANGELOG.md
+
@@ -1,10 +1,11 @@
+use std::num::NonZeroUsize;
 use std::path::{Path, PathBuf};
 use std::time::Duration;

 use anyhow::anyhow;
 use clap::{
-    error::ErrorKind, value_parser, Arg, ArgAction, ArgGroup, ArgMatches, Command, Parser,
-    ValueEnum,
+    Arg, ArgAction, ArgGroup, ArgMatches, Command, Parser, ValueEnum, error::ErrorKind,
+    value_parser,
 };
 #[cfg(feature = "completions")]
 use clap_complete::Shell;
@@ -21,7 +22,7 @@ use crate::filter::SizeFilter;
 #[command(
    name = "fd",
    version,
-    about = "A program to find entries in your filesystem",
+    about = "A program to find entries in your filesystem with regex and glob based matching. By default, fd respects gitignore rules, ignores hidden directories, and is case insensitive.",
    after_long_help = "Bugs can be reported on GitHub: https://github.com/sharkdp/fd/issues",
    max_term_width = 98,
    args_override_self = true,
@@ -32,6 +33,8 @@ pub struct Opts {
    /// Include hidden directories and files in the search results (default:
    /// hidden files and directories are skipped). Files and directories are
    /// considered to be hidden if their name starts with a `.` sign (dot).
+    /// Any files or directories that are ignored due to the rules described by
+    /// --no-ignore are still ignored unless otherwise specified.
    /// The flag can be overridden with --no-hidden.
    #[arg(
        long,
@@ -46,7 +49,7 @@ pub struct Opts {
    no_hidden: (),

    /// Show search results from files and directories that would otherwise be
-    /// ignored by '.gitignore', '.ignore', '.fdignore', or the global ignore file.
+    /// ignored by '.gitignore', '.ignore', '.fdignore', or the global ignore file,
    /// The flag can be overridden with --ignore.
    #[arg(
        long,
@@ -60,8 +63,9 @@ pub struct Opts {
    #[arg(long, overrides_with = "no_ignore", hide = true, action = ArgAction::SetTrue)]
    ignore: (),

-    ///Show search results from files and directories that would otherwise be
-    /// ignored by '.gitignore' files. The flag can be overridden with --ignore-vcs.
+    ///Show search results from files and directories that
+    ///would otherwise be ignored by '.gitignore' files.
+    ///The flag can be overridden with --ignore-vcs.
    #[arg(
        long,
        hide_short_help = true,
@@ -98,6 +102,7 @@ pub struct Opts {

    /// Show search results from files and directories that would otherwise be
    /// ignored by '.gitignore', '.ignore', or '.fdignore' files in parent directories.
+    /// The flag can be overridden with --ignore-parent.
    #[arg(
        long,
        hide_short_help = true,
@@ -106,6 +111,10 @@ pub struct Opts {
    )]
    pub no_ignore_parent: bool,

+    /// Overrides --no-ignore-parent
+    #[arg(long, overrides_with = "no_ignore_parent", hide = true, action = ArgAction::SetTrue)]
+    ignore_parent: (),
+
    /// Do not respect the global ignore file
    #[arg(long, hide = true)]
    pub no_global_ignore_file: bool,
@@ -164,17 +173,30 @@ pub struct Opts {

    /// Treat the pattern as a literal string instead of a regular expression. Note
    /// that this also performs substring comparison. If you want to match on an
-    /// exact filename, consider using '--glob'.
+    /// exact filename, consider using '--glob' or '--exact' instead.
    #[arg(
        long,
        short = 'F',
        alias = "literal",
        hide_short_help = true,
-        help = "Treat pattern as literal string stead of regex",
+        help = "Treat pattern as literal string instead of regex",
        long_help
    )]
    pub fixed_strings: bool,

+    /// Perform an exact match. This is equivalent to '--fixed-strings' but requires
+    /// the pattern to match the entire filename (or path if '--full-path' is used),
+    /// rather than a substring. Special regex characters in the pattern are treated
+    /// as literal characters.
+    #[arg(
+        long,
+        conflicts_with_all(["glob", "fixed_strings"]),
+        hide_short_help = true,
+        help = "Match the entire filename exactly (literal, non-substring)",
+        long_help
+    )]
+    pub exact: bool,
+
    /// Add additional required search patterns, all of which must be matched. Multiple
    /// additional patterns can be specified. The patterns are regular
    /// expressions, unless '--glob' or '--fixed-strings' is used.
@@ -222,7 +244,7 @@ pub struct Opts {
        alias = "dereference",
        long_help = "By default, fd does not descend into symlinked directories. Using this \
                     flag, symbolic links are also traversed. \
-                     Flag can be overriden with --no-follow."
+                     Flag can be overridden with --no-follow."
    )]
    pub follow: bool,

@@ -271,6 +293,7 @@ pub struct Opts {
        long,
        value_name = "depth",
        hide_short_help = true,
+        alias("mindepth"),
        help = "Only show search results starting at the given depth.",
        long_help
    )]
@@ -294,7 +317,7 @@ pub struct Opts {
    #[arg(
        long,
        short = 'E',
-        value_name = "pattern",
+        value_name = "glob",
        help = "Exclude entries that match the given glob pattern",
        long_help
    )]
@@ -309,10 +332,12 @@ pub struct Opts {

    /// Filter the search by type:
    /// {n}  'f' or 'file':         regular files
-    /// {n}  'd' or 'directory':    directories
+    /// {n}  'd' or 'dir' or 'directory':    directories
    /// {n}  'l' or 'symlink':      symbolic links
    /// {n}  's' or 'socket':       socket
    /// {n}  'p' or 'pipe':         named pipe (FIFO)
+    /// {n}  'b' or 'block-device': block device
+    /// {n}  'c' or 'char-device':  character device
    /// {n}{n}  'x' or 'executable':   executables
    /// {n}  'e' or 'empty':        empty files or directories
    ///
@@ -345,14 +370,16 @@ pub struct Opts {
        value_name = "filetype",
        hide_possible_values = true,
        value_enum,
-        help = "Filter by type: file (f), directory (d), symlink (l), \
-                executable (x), empty (e), socket (s), pipe (p)",
+        help = "Filter by type: file (f), directory (d/dir), symlink (l), \
+                executable (x), empty (e), socket (s), pipe (p), \
+                char-device (c), block-device (b)",
        long_help
    )]
    pub filetype: Option<Vec<FileType>>,

-    /// (Additionally) filter search results by their file extension. Multiple
-    /// allowable file extensions can be specified.
+    /// Filter results by extension. By default, this matches all entry types
+    /// (including directories whose names end with the extension). Use `--type`
+    /// to restrict the search to specific types. Multiple extensions can be specified.
    ///
    /// If you want to search for files without extension,
    /// you can use the regex '^[^.]+$' as a normal search pattern.
@@ -360,7 +387,7 @@ pub struct Opts {
        long = "extension",
        short = 'e',
        value_name = "ext",
-        help = "Filter by file extension",
+        help = "Filter by extension",
        long_help
    )]
    pub extensions: Option<Vec<String>>,
@@ -391,7 +418,7 @@ pub struct Opts {

    /// Filter results based on the file modification time. Files with modification times
    /// greater than the argument are returned. The argument can be provided
-    /// as a specific point in time (YYYY-MM-DD HH:MM:SS) or as a duration (10h, 1d, 35min).
+    /// as a specific point in time (YYYY-MM-DD HH:MM:SS or @timestamp) or as a duration (10h, 1d, 35min).
    /// If the time is not specified, it defaults to 00:00:00.
    /// '--change-newer-than', '--newer', or '--changed-after' can be used as aliases.
    ///
@@ -413,7 +440,7 @@ pub struct Opts {

    /// Filter results based on the file modification time. Files with modification times
    /// less than the argument are returned. The argument can be provided
-    /// as a specific point in time (YYYY-MM-DD HH:MM:SS) or as a duration (10h, 1d, 35min).
+    /// as a specific point in time (YYYY-MM-DD HH:MM:SS or @timestamp) or as a duration (10h, 1d, 35min).
    /// '--change-older-than' or '--older' can be used as aliases.
    ///
    /// Examples:
@@ -445,6 +472,20 @@ pub struct Opts {
        )]
    pub owner: Option<OwnerFilter>,

+    /// Instead of printing the file normally, print the format string with the following placeholders replaced:
+    ///   '{}': path (of the current search result)
+    ///   '{/}': basename
+    ///   '{//}': parent directory
+    ///   '{.}': path without file extension
+    ///   '{/.}': basename without file extension
+    #[arg(
+        long,
+        value_name = "fmt",
+        help = "Print results according to template",
+        conflicts_with = "list_details"
+    )]
+    pub format: Option<String>,
+
    #[command(flatten)]
    pub exec: Exec,

@@ -488,10 +529,32 @@ pub struct Opts {
    )]
    pub color: ColorWhen,

+    /// Add a terminal hyperlink to a file:// url for each path in the output.
+    ///
+    /// Auto mode  is used if no argument is given to this option.
+    ///
+    /// This doesn't do anything for --exec and --exec-batch.
+    #[arg(
+        long,
+        alias = "hyper",
+        value_name = "when",
+        require_equals = true,
+        value_enum,
+        default_value_t = HyperlinkWhen::Never,
+        default_missing_value = "auto",
+        num_args = 0..=1,
+        help = "Add hyperlinks to output paths"
+    )]
+    pub hyperlink: HyperlinkWhen,
+
+    /// Ignore directories containing the named entry.
+    #[arg(long, value_name = "name")]
+    pub ignore_contain: Vec<String>,
+
    /// Set number of threads to use for searching & executing (default: number
    /// of available CPU cores)
-    #[arg(long, short = 'j', value_name = "num", hide_short_help = true, value_parser = clap::value_parser!(u32).range(1..))]
-    pub threads: Option<u32>,
+    #[arg(long, short = 'j', value_name = "num", hide_short_help = true, value_parser = str::parse::<NonZeroUsize>)]
+    pub threads: Option<NonZeroUsize>,

    /// Milliseconds to buffer before streaming search results to console
    ///
@@ -554,6 +617,7 @@ pub struct Opts {
    /// relative to this directory.
    #[arg(
        long,
+        short = 'C',
        value_name = "path",
        hide_short_help = true,
        help = "Change current working directory",
@@ -610,9 +674,10 @@ pub struct Opts {
    /// By default, relative paths are prefixed with './' when -x/--exec,
    /// -X/--exec-batch, or -0/--print0 are given, to reduce the risk of a
    /// path starting with '-' being treated as a command line option. Use
-    /// this flag to disable this behaviour.
-    #[arg(long, conflicts_with_all(&["path", "search_path"]), hide_short_help = true, long_help)]
-    pub strip_cwd_prefix: bool,
+    /// this flag to change this behavior. If this flag is used without a value,
+    /// it is equivalent to passing "always".
+    #[arg(long, conflicts_with_all(&["path", "search_path"]), value_name = "when", hide_short_help = true, require_equals = true, long_help)]
+    strip_cwd_prefix: Option<Option<StripCwdWhen>>,

    /// By default, fd will traverse the file system tree as far as other options
    /// dictate. With this flag, fd ensures that it does not descend into a
@@ -635,7 +700,7 @@ impl Opts {
        } else if !self.search_path.is_empty() {
            &self.search_path
        } else {
-            let current_directory = Path::new(".");
+            let current_directory = Path::new("./");
            ensure_current_directory_exists(current_directory)?;
            return Ok(vec![self.normalize_path(current_directory)]);
        };
@@ -658,6 +723,13 @@ impl Opts {
    fn normalize_path(&self, path: &Path) -> PathBuf {
        if self.absolute_path {
            filesystem::absolute_path(path.normalize().unwrap().as_path()).unwrap()
+        } else if path == Path::new(".") {
+            // Change "." to "./" as a workaround for https://github.com/BurntSushi/ripgrep/pull/2711
+            PathBuf::from("./")
+        } else if path == Path::new("-") {
+            // Prefix "-" so the underlying walker treats it as a path.
+            // See sharkdp/fd#849.
+            Path::new(".").join(path)
        } else {
            path.to_path_buf()
        }
@@ -680,17 +752,8 @@ impl Opts {
        self.min_depth.or(self.exact_depth)
    }

-    pub fn threads(&self) -> usize {
-        // This will panic if the number of threads passed in is more than usize::MAX in an environment
-        // where usize is less than 32 bits (for example 16-bit architectures). It's pretty
-        // unlikely fd will be running in such an environment, and even more unlikely someone would
-        // be trying to use that many threads on such an environment, so I think panicing is an
-        // appropriate way to handle that.
-        std::cmp::max(
-            self.threads
-                .map_or_else(num_cpus::get, |n| n.try_into().expect("too many threads")),
-            1,
-        )
+    pub fn threads(&self) -> NonZeroUsize {
+        self.threads.unwrap_or_else(default_num_threads)
    }

    pub fn max_results(&self) -> Option<usize> {
@@ -699,6 +762,16 @@ impl Opts {
            .or_else(|| self.max_one_result.then_some(1))
    }

+    pub fn strip_cwd_prefix<P: FnOnce() -> bool>(&self, auto_pred: P) -> bool {
+        use self::StripCwdWhen::*;
+        self.no_search_paths()
+            && match self.strip_cwd_prefix.map_or(Auto, |o| o.unwrap_or(Always)) {
+                Auto => auto_pred(),
+                Always => true,
+                Never => false,
+            }
+    }
+
    #[cfg(feature = "completions")]
    pub fn gen_completions(&self) -> anyhow::Result<Option<Shell>> {
        self.gen_completions
@@ -712,14 +785,32 @@ impl Opts {
    }
 }

+/// Get the default number of threads to use, if not explicitly specified.
+fn default_num_threads() -> NonZeroUsize {
+    // If we can't get the amount of parallelism for some reason, then
+    // default to a single thread, because that is safe.
+    let fallback = NonZeroUsize::MIN;
+    // To limit startup overhead on massively parallel machines, don't use more
+    // than 64 threads.
+    let limit = NonZeroUsize::new(64).unwrap();
+
+    std::thread::available_parallelism()
+        .unwrap_or(fallback)
+        .min(limit)
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, ValueEnum)]
 pub enum FileType {
    #[value(alias = "f")]
    File,
-    #[value(alias = "d")]
+    #[value(alias = "d", alias = "dir")]
    Directory,
    #[value(alias = "l")]
    Symlink,
+    #[value(alias = "b")]
+    BlockDevice,
+    #[value(alias = "c")]
+    CharDevice,
    /// A file which is executable by the current effective user
    #[value(alias = "x")]
    Executable,
@@ -741,15 +832,24 @@ pub enum ColorWhen {
    Never,
 }

-impl ColorWhen {
-    pub fn as_str(&self) -> &'static str {
-        use ColorWhen::*;
-        match *self {
-            Auto => "auto",
-            Never => "never",
-            Always => "always",
-        }
-    }
+#[derive(Copy, Clone, PartialEq, Eq, Debug, ValueEnum)]
+pub enum StripCwdWhen {
+    /// Use the default behavior
+    Auto,
+    /// Always strip the ./ at the beginning of paths
+    Always,
+    /// Never strip the ./
+    Never,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, ValueEnum)]
+pub enum HyperlinkWhen {
+    /// Use hyperlinks only if color is enabled
+    Auto,
+    /// Always use hyperlinks when printing file paths
+    Always,
+    /// Never use hyperlinks
+    Never,
 }

 // there isn't a derive api for getting grouped values yet,
@@ -793,20 +893,26 @@ impl clap::Args for Exec {
                .help("Execute a command for each search result")
                .long_help(
                    "Execute a command for each search result in parallel (use --threads=1 for sequential command execution). \
+                     There is no guarantee of the order commands are executed in, and the order should not be depended upon. \
                     All positional arguments following --exec are considered to be arguments to the command - not to fd. \
-                     It is therefore recommended to place the '-x'/'--exec' option last.\n\
+                     It is therefore recommended to place the '-x'/'--exec' option last. \
+                     Use '\\;' to terminate the command template if you need to continue passing fd arguments afterwards.\n\
                     The following placeholders are substituted before the command is executed:\n  \
                       '{}':   path (of the current search result)\n  \
                       '{/}':  basename\n  \
                       '{//}': parent directory\n  \
                       '{.}':  path without file extension\n  \
-                       '{/.}': basename without file extension\n\n\
+                       '{/.}': basename without file extension\n  \
+                       '{{':   literal '{' (for escaping)\n  \
+                       '}}':   literal '}' (for escaping)\n\n\
                     If no placeholder is present, an implicit \"{}\" at the end is assumed.\n\n\
                     Examples:\n\n  \
                       - find all *.zip files and unzip them:\n\n      \
                           fd -e zip -x unzip\n\n  \
                       - find *.h and *.cpp files and run \"clang-format -i ..\" for each of them:\n\n      \
                           fd -e h -e cpp -x clang-format -i\n\n  \
+                       - search within `src/` and echo each match (place `-x` last):\n\n      \
+                           fd . src -x echo\n\n  \
                       - Convert all *.jpg files to *.png files:\n\n      \
                           fd -e jpg -x convert {} {.}.png\
                    ",
@@ -825,12 +931,15 @@ impl clap::Args for Exec {
                .help("Execute a command with all search results at once")
                .long_help(
                    "Execute the given command once, with all search results as arguments.\n\
+                     The order of the arguments is non-deterministic, and should not be relied upon.\n\
                     One of the following placeholders is substituted before the command is executed:\n  \
                       '{}':   path (of all search results)\n  \
                       '{/}':  basename\n  \
                       '{//}': parent directory\n  \
                       '{.}':  path without file extension\n  \
-                       '{/.}': basename without file extension\n\n\
+                       '{/.}': basename without file extension\n  \
+                       '{{':   literal '{' (for escaping)\n  \
+                       '}}':   literal '}' (for escaping)\n\n\
                     If no placeholder is present, an implicit \"{}\" at the end is assumed.\n\n\
                     Examples:\n\n  \
                       - Find all test_*.py files and open them in your favorite editor:\n\n      \
@@ -8,15 +8,16 @@ use crate::filetypes::FileTypes;
 #[cfg(unix)]
 use crate::filter::OwnerFilter;
 use crate::filter::{SizeFilter, TimeFilter};
+use crate::fmt::FormatTemplate;

 /// Configuration options for *fd*.
 pub struct Config {
    /// Whether the search is case-sensitive or case-insensitive.
    pub case_sensitive: bool,

-    /// Whether to search within the full file path or just the base name (filename or directory
-    /// name).
-    pub search_full_path: bool,
+    /// Cached current working directory for absolute path construction.
+    /// Populated when `--full-path` is set; `None` means search by filename only.
+    pub full_path_base: Option<PathBuf>,

    /// Whether to ignore hidden files and directories (or not).
    pub ignore_hidden: bool,
@@ -74,6 +75,7 @@ pub struct Config {
    pub ls_colors: Option<LsColors>,

    /// Whether or not we are writing to an interactive terminal
+    #[cfg_attr(not(unix), allow(unused))]
    pub interactive_terminal: bool,

    /// The type of file to search for. If set to `None`, all file types are displayed. If
@@ -85,6 +87,9 @@ pub struct Config {
    /// The value (if present) will be a lowercase string without leading dots.
    pub extensions: Option<RegexSet>,

+    /// A format string to use to format results, similarly to exec
+    pub format: Option<FormatTemplate>,
+
    /// If a value is supplied, each item found will be used to generate and execute commands.
    pub command: Option<Arc<CommandSet>>,

@@ -122,6 +127,12 @@ pub struct Config {

    /// Whether or not to strip the './' prefix for search results
    pub strip_cwd_prefix: bool,
+
+    /// Whether or not to use hyperlinks on paths
+    pub hyperlink: bool,
+
+    /// Names that should stop traversal down their parent. (e.g. https://bford.info/cachedir/).
+    pub ignore_contain: Vec<String>,
 }

 impl Config {
@@ -8,11 +8,13 @@ use lscolors::{Colorable, LsColors, Style};
 use crate::config::Config;
 use crate::filesystem::strip_current_dir;

+#[derive(Debug)]
 enum DirEntryInner {
    Normal(ignore::DirEntry),
    BrokenSymlink(PathBuf),
 }

+#[derive(Debug)]
 pub struct DirEntry {
    inner: DirEntryInner,
    metadata: OnceCell<Option<Metadata>>,
@@ -52,11 +54,19 @@ impl DirEntry {
    }

    /// Returns the path as it should be presented to the user.
+    /// When stripping `./` would leave the path starting with `-`, keep the original
+    /// (with `./`) so downstream tools don't interpret it as an option.
    pub fn stripped_path(&self, config: &Config) -> &Path {
+        let path = self.path();
        if config.strip_cwd_prefix {
-            strip_current_dir(self.path())
+            let stripped = strip_current_dir(path);
+            if starts_with_dash(stripped) {
+                path
+            } else {
+                stripped
+            }
        } else {
-            self.path()
+            path
        }
    }

@@ -99,6 +109,10 @@ impl DirEntry {
    }
 }

+fn starts_with_dash(path: &Path) -> bool {
+    path.as_os_str().as_encoded_bytes().first() == Some(&b'-')
+}
+
 impl PartialEq for DirEntry {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
@@ -111,7 +125,7 @@ impl Eq for DirEntry {}
 impl PartialOrd for DirEntry {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.path().partial_cmp(other.path())
+        Some(self.cmp(other))
    }
 }

@@ -135,7 +149,7 @@ impl Colorable for DirEntry {
                // but we want it for all component types, so we open code it.
                // Copied from LsColors::style_for_path_with_metadata().
                path.components()
-                    .last()
+                    .next_back()
                    .map(|c| c.as_os_str())
                    .unwrap_or_else(|| path.as_os_str())
            }
@@ -151,3 +165,25 @@ impl Colorable for DirEntry {
        self.metadata().cloned()
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::starts_with_dash;
+    use std::path::Path;
+
+    #[test]
+    fn dash_prefixed_paths_detected() {
+        assert!(starts_with_dash(Path::new("-rf")));
+        assert!(starts_with_dash(Path::new("--delete")));
+        assert!(starts_with_dash(Path::new("-")));
+    }
+
+    #[test]
+    fn safe_paths_not_flagged() {
+        assert!(!starts_with_dash(Path::new("foo")));
+        assert!(!starts_with_dash(Path::new("./foo")));
+        assert!(!starts_with_dash(Path::new("sub/-rf")));
+        assert!(!starts_with_dash(Path::new("")));
+        assert!(!starts_with_dash(Path::new(" -rf")));
+    }
+}
@@ -1,3 +1,9 @@
+use std::io::IsTerminal;
+
+use crate::sanitize::maybe_sanitize;
+
 pub fn print_error(msg: impl Into<String>) {
-    eprintln!("[fd error]: {}", msg.into());
+    let msg = msg.into();
+    let safe = maybe_sanitize(&msg, std::io::stderr().is_terminal());
+    eprintln!("[fd error]: {safe}");
 }
@@ -1,6 +1,5 @@
 use std::io;
 use std::io::Write;
-use std::sync::Mutex;

 use argmax::Command;

@@ -11,15 +10,15 @@ struct Outputs {
    stdout: Vec<u8>,
    stderr: Vec<u8>,
 }
-struct OutputBuffer<'a> {
-    output_permission: &'a Mutex<()>,
+pub struct OutputBuffer {
+    null_separator: bool,
    outputs: Vec<Outputs>,
 }

-impl<'a> OutputBuffer<'a> {
-    fn new(output_permission: &'a Mutex<()>) -> Self {
+impl OutputBuffer {
+    pub fn new(null_separator: bool) -> Self {
        Self {
-            output_permission,
+            null_separator,
            outputs: Vec::new(),
        }
    }
@@ -29,17 +28,19 @@ impl<'a> OutputBuffer<'a> {
    }

    fn write(self) {
-        // avoid taking the lock if there is nothing to do
-        if self.outputs.is_empty() {
+        // Avoid taking the lock if there is nothing to do.
+        // If null_separator is true, then we still need to write the
+        // null separator, because the output may have been written directly
+        // to stdout
+        if self.outputs.is_empty() && !self.null_separator {
            return;
        }
-        // While this lock is active, this thread will be the only thread allowed
-        // to write its outputs.
-        let _lock = self.output_permission.lock().unwrap();

        let stdout = io::stdout();
        let stderr = io::stderr();

+        // While we hold these locks, only this thread will be able
+        // to write its outputs.
        let mut stdout = stdout.lock();
        let mut stderr = stderr.lock();

@@ -47,16 +48,20 @@ impl<'a> OutputBuffer<'a> {
            let _ = stdout.write_all(&output.stdout);
            let _ = stderr.write_all(&output.stderr);
        }
+        if self.null_separator {
+            // If null_separator is enabled, then we should write a \0 at the end
+            // of the output for this entry
+            let _ = stdout.write_all(b"\0");
+        }
    }
 }

 /// Executes a command.
 pub fn execute_commands<I: Iterator<Item = io::Result<Command>>>(
    cmds: I,
-    out_perm: &Mutex<()>,
+    mut output_buffer: OutputBuffer,
    enable_output_buffering: bool,
 ) -> ExitCode {
-    let mut output_buffer = OutputBuffer::new(out_perm);
    for result in cmds {
        let mut cmd = match result {
            Ok(cmd) => cmd,
@@ -103,7 +108,7 @@ pub fn handle_cmd_error(cmd: Option<&Command>, err: io::Error) -> ExitCode {
            ExitCode::GeneralError
        }
        (_, err) => {
-            print_error(format!("Problem while executing command: {}", err));
+            print_error(format!("Problem while executing command: {err}"));
            ExitCode::GeneralError
        }
    }
@@ -1,11 +1,6 @@
-use std::sync::Mutex;
-
-use crossbeam_channel::Receiver;
-
 use crate::config::Config;
-use crate::dir_entry::DirEntry;
 use crate::error::print_error;
-use crate::exit_codes::{merge_exitcodes, ExitCode};
+use crate::exit_codes::{ExitCode, merge_exitcodes};
 use crate::walk::WorkerResult;

 use super::CommandSet;
@@ -14,43 +9,46 @@ use super::CommandSet;
 /// generate a command with the supplied command template. The generated command will then
 /// be executed, and this process will continue until the receiver's sender has closed.
 pub fn job(
-    rx: Receiver<WorkerResult>,
+    results: impl IntoIterator<Item = WorkerResult>,
    cmd: &CommandSet,
-    out_perm: &Mutex<()>,
    config: &Config,
 ) -> ExitCode {
    // Output should be buffered when only running a single thread
    let buffer_output: bool = config.threads > 1;

-    let mut results: Vec<ExitCode> = Vec::new();
-    loop {
+    let mut ret = ExitCode::Success;
+    for result in results {
        // Obtain the next result from the receiver, else if the channel
        // has closed, exit from the loop
-        let dir_entry: DirEntry = match rx.recv() {
-            Ok(WorkerResult::Entry(dir_entry)) => dir_entry,
-            Ok(WorkerResult::Error(err)) => {
+        let dir_entry = match result {
+            WorkerResult::Entry(dir_entry) => dir_entry,
+            WorkerResult::Error(err) => {
                if config.show_filesystem_errors {
                    print_error(err.to_string());
                }
                continue;
            }
-            Err(_) => break,
        };

        // Generate a command, execute it and store its exit code.
-        results.push(cmd.execute(
+        let code = cmd.execute(
            dir_entry.stripped_path(config),
            config.path_separator.as_deref(),
-            out_perm,
+            config.null_separator,
            buffer_output,
-        ))
+        );
+        ret = merge_exitcodes([ret, code]);
    }
    // Returns error in case of any error.
-    merge_exitcodes(results)
+    ret
 }

-pub fn batch(rx: Receiver<WorkerResult>, cmd: &CommandSet, config: &Config) -> ExitCode {
-    let paths = rx
+pub fn batch(
+    results: impl IntoIterator<Item = WorkerResult>,
+    cmd: &CommandSet,
+    config: &Config,
+) -> ExitCode {
+    let paths = results
        .into_iter()
        .filter_map(|worker_result| match worker_result {
            WorkerResult::Entry(dir_entry) => Some(dir_entry.into_stripped_path(config)),
@@ -1,26 +1,21 @@
 mod command;
-mod input;
 mod job;
-mod token;

-use std::borrow::Cow;
-use std::ffi::{OsStr, OsString};
+use std::ffi::OsString;
 use std::io;
 use std::iter;
-use std::path::{Component, Path, PathBuf, Prefix};
+use std::path::{Path, PathBuf};
 use std::process::Stdio;
-use std::sync::{Mutex, OnceLock};

-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use argmax::Command;
-use regex::Regex;

-use crate::exit_codes::{merge_exitcodes, ExitCode};
+use crate::exec::command::OutputBuffer;
+use crate::exit_codes::{ExitCode, merge_exitcodes};
+use crate::fmt::{FormatTemplate, Token};

 use self::command::{execute_commands, handle_cmd_error};
-use self::input::{basename, dirname, remove_extension};
 pub use self::job::{batch, job};
-use self::token::Token;

 /// Execution mode of the command
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -48,7 +43,7 @@ impl CommandSet {
            mode: ExecutionMode::OneByOne,
            commands: input
                .into_iter()
-                .map(CommandTemplate::new)
+                .map(|args| CommandTemplate::new(args, ExecutionMode::OneByOne))
                .collect::<Result<_>>()?,
        })
    }
@@ -64,13 +59,10 @@ impl CommandSet {
            commands: input
                .into_iter()
                .map(|args| {
-                    let cmd = CommandTemplate::new(args)?;
+                    let cmd = CommandTemplate::new(args, ExecutionMode::Batch)?;
                    if cmd.number_of_tokens() > 1 {
                        bail!("Only one placeholder allowed for batch commands");
                    }
-                    if cmd.args[0].has_tokens() {
-                        bail!("First argument of exec-batch is expected to be a fixed executable");
-                    }
                    Ok(cmd)
                })
                .collect::<Result<Vec<_>>>()?,
@@ -85,14 +77,14 @@ impl CommandSet {
        &self,
        input: &Path,
        path_separator: Option<&str>,
-        out_perm: &Mutex<()>,
+        null_separator: bool,
        buffer_output: bool,
    ) -> ExitCode {
        let commands = self
            .commands
            .iter()
            .map(|c| c.generate(input, path_separator));
-        execute_commands(commands, out_perm, buffer_output)
+        execute_commands(commands, OutputBuffer::new(null_separator), buffer_output)
    }

    pub fn execute_batch<I>(&self, paths: I, limit: usize, path_separator: Option<&str>) -> ExitCode
@@ -132,7 +124,7 @@ impl CommandSet {
 #[derive(Debug)]
 struct CommandBuilder {
    pre_args: Vec<OsString>,
-    path_arg: ArgumentTemplate,
+    path_arg: FormatTemplate,
    post_args: Vec<OsString>,
    cmd: Command,
    count: usize,
@@ -221,61 +213,24 @@ impl CommandBuilder {
 /// `generate_and_execute()` method will be used to generate a command and execute it.
 #[derive(Debug, Clone, PartialEq)]
 struct CommandTemplate {
-    args: Vec<ArgumentTemplate>,
+    args: Vec<FormatTemplate>,
 }

 impl CommandTemplate {
-    fn new<I, S>(input: I) -> Result<CommandTemplate>
+    fn new<I, S>(input: I, mode: ExecutionMode) -> Result<CommandTemplate>
    where
        I: IntoIterator<Item = S>,
        S: AsRef<str>,
    {
-        static PLACEHOLDER_PATTERN: OnceLock<Regex> = OnceLock::new();
-
        let mut args = Vec::new();
        let mut has_placeholder = false;

        for arg in input {
            let arg = arg.as_ref();

-            let mut tokens = Vec::new();
-            let mut start = 0;
-
-            let pattern =
-                PLACEHOLDER_PATTERN.get_or_init(|| Regex::new(r"\{(/?\.?|//)\}").unwrap());
-
-            for placeholder in pattern.find_iter(arg) {
-                // Leading text before the placeholder.
-                if placeholder.start() > start {
-                    tokens.push(Token::Text(arg[start..placeholder.start()].to_owned()));
-                }
-
-                start = placeholder.end();
-
-                match placeholder.as_str() {
-                    "{}" => tokens.push(Token::Placeholder),
-                    "{.}" => tokens.push(Token::NoExt),
-                    "{/}" => tokens.push(Token::Basename),
-                    "{//}" => tokens.push(Token::Parent),
-                    "{/.}" => tokens.push(Token::BasenameNoExt),
-                    _ => unreachable!("Unhandled placeholder"),
-                }
-
-                has_placeholder = true;
-            }
-
-            // Without a placeholder, the argument is just fixed text.
-            if tokens.is_empty() {
-                args.push(ArgumentTemplate::Text(arg.to_owned()));
-                continue;
-            }
-
-            if start < arg.len() {
-                // Trailing text after last placeholder.
-                tokens.push(Token::Text(arg[start..].to_owned()));
-            }
-
-            args.push(ArgumentTemplate::Tokens(tokens));
+            let tmpl = FormatTemplate::parse(arg);
+            has_placeholder |= tmpl.has_tokens();
+            args.push(tmpl);
        }

        // We need to check that we have at least one argument, because if not
@@ -287,9 +242,14 @@ impl CommandTemplate {
            bail!("No executable provided for --exec or --exec-batch");
        }

+        // A placeholder as the executable is meaningful for `--exec` but never for `--exec-batch`.
+        if mode == ExecutionMode::Batch && args[0].has_tokens() {
+            bail!("First argument of --exec-batch must be a fixed executable, not a placeholder");
+        }
+
        // If a placeholder token was not supplied, append one at the end of the command.
        if !has_placeholder {
-            args.push(ArgumentTemplate::Tokens(vec![Token::Placeholder]));
+            args.push(FormatTemplate::Tokens(vec![Token::Placeholder]));
        }

        Ok(CommandTemplate { args })
@@ -312,115 +272,18 @@ impl CommandTemplate {
    }
 }

-/// Represents a template for a single command argument.
-///
-/// The argument is either a collection of `Token`s including at least one placeholder variant, or
-/// a fixed text.
-#[derive(Clone, Debug, PartialEq)]
-enum ArgumentTemplate {
-    Tokens(Vec<Token>),
-    Text(String),
-}
-
-impl ArgumentTemplate {
-    pub fn has_tokens(&self) -> bool {
-        matches!(self, ArgumentTemplate::Tokens(_))
-    }
-
-    /// Generate an argument from this template. If path_separator is Some, then it will replace
-    /// the path separator in all placeholder tokens. Text arguments and tokens are not affected by
-    /// path separator substitution.
-    pub fn generate(&self, path: impl AsRef<Path>, path_separator: Option<&str>) -> OsString {
-        use self::Token::*;
-        let path = path.as_ref();
-
-        match *self {
-            ArgumentTemplate::Tokens(ref tokens) => {
-                let mut s = OsString::new();
-                for token in tokens {
-                    match *token {
-                        Basename => s.push(Self::replace_separator(basename(path), path_separator)),
-                        BasenameNoExt => s.push(Self::replace_separator(
-                            &remove_extension(basename(path).as_ref()),
-                            path_separator,
-                        )),
-                        NoExt => s.push(Self::replace_separator(
-                            &remove_extension(path),
-                            path_separator,
-                        )),
-                        Parent => s.push(Self::replace_separator(&dirname(path), path_separator)),
-                        Placeholder => {
-                            s.push(Self::replace_separator(path.as_ref(), path_separator))
-                        }
-                        Text(ref string) => s.push(string),
-                    }
-                }
-                s
-            }
-            ArgumentTemplate::Text(ref text) => OsString::from(text),
-        }
-    }
-
-    /// Replace the path separator in the input with the custom separator string. If path_separator
-    /// is None, simply return a borrowed Cow<OsStr> of the input. Otherwise, the input is
-    /// interpreted as a Path and its components are iterated through and re-joined into a new
-    /// OsString.
-    fn replace_separator<'a>(path: &'a OsStr, path_separator: Option<&str>) -> Cow<'a, OsStr> {
-        // fast-path - no replacement necessary
-        if path_separator.is_none() {
-            return Cow::Borrowed(path);
-        }
-
-        let path_separator = path_separator.unwrap();
-        let mut out = OsString::with_capacity(path.len());
-        let mut components = Path::new(path).components().peekable();
-
-        while let Some(comp) = components.next() {
-            match comp {
-                // Absolute paths on Windows are tricky.  A Prefix component is usually a drive
-                // letter or UNC path, and is usually followed by RootDir. There are also
-                // "verbatim" prefixes beginning with "\\?\" that skip normalization. We choose to
-                // ignore verbatim path prefixes here because they're very rare, might be
-                // impossible to reach here, and there's no good way to deal with them. If users
-                // are doing something advanced involving verbatim windows paths, they can do their
-                // own output filtering with a tool like sed.
-                Component::Prefix(prefix) => {
-                    if let Prefix::UNC(server, share) = prefix.kind() {
-                        // Prefix::UNC is a parsed version of '\\server\share'
-                        out.push(path_separator);
-                        out.push(path_separator);
-                        out.push(server);
-                        out.push(path_separator);
-                        out.push(share);
-                    } else {
-                        // All other Windows prefix types are rendered as-is. This results in e.g. "C:" for
-                        // drive letters. DeviceNS and Verbatim* prefixes won't have backslashes converted,
-                        // but they're not returned by directories fd can search anyway so we don't worry
-                        // about them.
-                        out.push(comp.as_os_str());
-                    }
-                }
-
-                // Root directory is always replaced with the custom separator.
-                Component::RootDir => out.push(path_separator),
-
-                // Everything else is joined normally, with a trailing separator if we're not last
-                _ => {
-                    out.push(comp.as_os_str());
-                    if components.peek().is_some() {
-                        out.push(path_separator);
-                    }
-                }
-            }
-        }
-        Cow::Owned(out)
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;

+    fn generate_str(template: &CommandTemplate, input: &str) -> Vec<String> {
+        template
+            .args
+            .iter()
+            .map(|arg| arg.generate(input, None).into_string().unwrap())
+            .collect()
+    }
+
    #[test]
    fn tokens_with_placeholder() {
        assert_eq!(
@@ -428,9 +291,9 @@ mod tests {
            CommandSet {
                commands: vec![CommandTemplate {
                    args: vec![
-                        ArgumentTemplate::Text("echo".into()),
-                        ArgumentTemplate::Text("${SHELL}:".into()),
-                        ArgumentTemplate::Tokens(vec![Token::Placeholder]),
+                        FormatTemplate::Text("echo".into()),
+                        FormatTemplate::Text("${SHELL}:".into()),
+                        FormatTemplate::Tokens(vec![Token::Placeholder]),
                    ]
                }],
                mode: ExecutionMode::OneByOne,
@@ -445,8 +308,8 @@ mod tests {
            CommandSet {
                commands: vec![CommandTemplate {
                    args: vec![
-                        ArgumentTemplate::Text("echo".into()),
-                        ArgumentTemplate::Tokens(vec![Token::NoExt]),
+                        FormatTemplate::Text("echo".into()),
+                        FormatTemplate::Tokens(vec![Token::NoExt]),
                    ],
                }],
                mode: ExecutionMode::OneByOne,
@@ -461,8 +324,8 @@ mod tests {
            CommandSet {
                commands: vec![CommandTemplate {
                    args: vec![
-                        ArgumentTemplate::Text("echo".into()),
-                        ArgumentTemplate::Tokens(vec![Token::Basename]),
+                        FormatTemplate::Text("echo".into()),
+                        FormatTemplate::Tokens(vec![Token::Basename]),
                    ],
                }],
                mode: ExecutionMode::OneByOne,
@@ -477,8 +340,8 @@ mod tests {
            CommandSet {
                commands: vec![CommandTemplate {
                    args: vec![
-                        ArgumentTemplate::Text("echo".into()),
-                        ArgumentTemplate::Tokens(vec![Token::Parent]),
+                        FormatTemplate::Text("echo".into()),
+                        FormatTemplate::Tokens(vec![Token::Parent]),
                    ],
                }],
                mode: ExecutionMode::OneByOne,
@@ -493,8 +356,8 @@ mod tests {
            CommandSet {
                commands: vec![CommandTemplate {
                    args: vec![
-                        ArgumentTemplate::Text("echo".into()),
-                        ArgumentTemplate::Tokens(vec![Token::BasenameNoExt]),
+                        FormatTemplate::Text("echo".into()),
+                        FormatTemplate::Tokens(vec![Token::BasenameNoExt]),
                    ],
                }],
                mode: ExecutionMode::OneByOne,
@@ -502,6 +365,23 @@ mod tests {
        );
    }

+    #[test]
+    fn tokens_with_literal_braces() {
+        let template =
+            CommandTemplate::new(vec!["{{}}", "{{", "{.}}"], ExecutionMode::OneByOne).unwrap();
+        assert_eq!(
+            generate_str(&template, "foo"),
+            vec!["{}", "{", "{.}", "foo"]
+        );
+    }
+
+    #[test]
+    fn tokens_with_literal_braces_and_placeholder() {
+        let template =
+            CommandTemplate::new(vec!["echo", "{{{},end}"], ExecutionMode::OneByOne).unwrap();
+        assert_eq!(generate_str(&template, "foo"), vec!["echo", "{foo,end}"]);
+    }
+
    #[test]
    fn tokens_multiple() {
        assert_eq!(
@@ -509,9 +389,9 @@ mod tests {
            CommandSet {
                commands: vec![CommandTemplate {
                    args: vec![
-                        ArgumentTemplate::Text("cp".into()),
-                        ArgumentTemplate::Tokens(vec![Token::Placeholder]),
-                        ArgumentTemplate::Tokens(vec![
+                        FormatTemplate::Text("cp".into()),
+                        FormatTemplate::Tokens(vec![Token::Placeholder]),
+                        FormatTemplate::Tokens(vec![
                            Token::BasenameNoExt,
                            Token::Text(".ext".into())
                        ]),
@@ -529,8 +409,8 @@ mod tests {
            CommandSet {
                commands: vec![CommandTemplate {
                    args: vec![
-                        ArgumentTemplate::Text("echo".into()),
-                        ArgumentTemplate::Tokens(vec![Token::NoExt]),
+                        FormatTemplate::Text("echo".into()),
+                        FormatTemplate::Tokens(vec![Token::NoExt]),
                    ],
                }],
                mode: ExecutionMode::Batch,
@@ -545,7 +425,9 @@ mod tests {

    #[test]
    fn template_no_args() {
-        assert!(CommandTemplate::new::<Vec<_>, &'static str>(vec![]).is_err());
+        assert!(
+            CommandTemplate::new::<Vec<_>, &'static str>(vec![], ExecutionMode::OneByOne).is_err()
+        );
    }

    #[test]
@@ -553,9 +435,16 @@ mod tests {
        assert!(CommandSet::new(vec![vec!["echo"], vec![]]).is_err());
    }

+    #[test]
+    fn placeholder_as_executable_rejected() {
+        assert!(CommandSet::new(vec![vec!["{}"]]).is_ok());
+        assert!(CommandSet::new(vec![vec!["{/}", "arg"]]).is_ok());
+        assert!(CommandSet::new_batch(vec![vec!["{}"]]).is_err());
+    }
+
    #[test]
    fn generate_custom_path_separator() {
-        let arg = ArgumentTemplate::Tokens(vec![Token::Placeholder]);
+        let arg = FormatTemplate::Tokens(vec![Token::Placeholder]);
        macro_rules! check {
            ($input:expr, $expected:expr) => {
                assert_eq!(arg.generate($input, Some("#")), OsString::from($expected));
@@ -570,7 +459,7 @@ mod tests {
    #[cfg(windows)]
    #[test]
    fn generate_custom_path_separator_windows() {
-        let arg = ArgumentTemplate::Tokens(vec![Token::Placeholder]);
+        let arg = FormatTemplate::Tokens(vec![Token::Placeholder]);
        macro_rules! check {
            ($input:expr, $expected:expr) => {
                assert_eq!(arg.generate($input, Some("#")), OsString::from($expected));
@@ -1,29 +0,0 @@
-use std::fmt::{self, Display, Formatter};
-
-/// Designates what should be written to a buffer
-///
-/// Each `Token` contains either text, or a placeholder variant, which will be used to generate
-/// commands after all tokens for a given command template have been collected.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Token {
-    Placeholder,
-    Basename,
-    Parent,
-    NoExt,
-    BasenameNoExt,
-    Text(String),
-}
-
-impl Display for Token {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match *self {
-            Token::Placeholder => f.write_str("{}")?,
-            Token::Basename => f.write_str("{/}")?,
-            Token::Parent => f.write_str("{//}")?,
-            Token::NoExt => f.write_str("{.}")?,
-            Token::BasenameNoExt => f.write_str("{/.}")?,
-            Token::Text(ref string) => f.write_str(string)?,
-        }
-        Ok(())
-    }
-}
@@ -1,7 +1,7 @@
 use std::process;

 #[cfg(unix)]
-use nix::sys::signal::{raise, signal, SigHandler, Signal};
+use nix::sys::signal::{SigHandler, Signal, raise, signal};

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ExitCode {
@@ -59,6 +59,26 @@ pub fn is_empty(entry: &dir_entry::DirEntry) -> bool {
    }
 }

+#[cfg(any(unix, target_os = "redox"))]
+pub fn is_block_device(ft: fs::FileType) -> bool {
+    ft.is_block_device()
+}
+
+#[cfg(windows)]
+pub fn is_block_device(_: fs::FileType) -> bool {
+    false
+}
+
+#[cfg(any(unix, target_os = "redox"))]
+pub fn is_char_device(ft: fs::FileType) -> bool {
+    ft.is_char_device()
+}
+
+#[cfg(windows)]
+pub fn is_char_device(_: fs::FileType) -> bool {
+    false
+}
+
 #[cfg(any(unix, target_os = "redox"))]
 pub fn is_socket(ft: fs::FileType) -> bool {
    ft.is_socket()
@@ -80,13 +100,13 @@ pub fn is_pipe(_: fs::FileType) -> bool {
 }

 #[cfg(any(unix, target_os = "redox"))]
-pub fn osstr_to_bytes(input: &OsStr) -> Cow<[u8]> {
+pub fn osstr_to_bytes(input: &OsStr) -> Cow<'_, [u8]> {
    use std::os::unix::ffi::OsStrExt;
    Cow::Borrowed(input.as_bytes())
 }

 #[cfg(windows)]
-pub fn osstr_to_bytes(input: &OsStr) -> Cow<[u8]> {
+pub fn osstr_to_bytes(input: &OsStr) -> Cow<'_, [u8]> {
    let string = input.to_string_lossy();

    match string {
@@ -108,13 +128,11 @@ pub fn strip_current_dir(path: &Path) -> &Path {
 pub fn default_path_separator() -> Option<String> {
    if cfg!(windows) {
        let msystem = env::var("MSYSTEM").ok()?;
-        match msystem.as_str() {
-            "MINGW64" | "MINGW32" | "MSYS" => Some("/".to_owned()),
-            _ => None,
+        if !msystem.is_empty() {
+            return Some("/".to_owned());
        }
-    } else {
-        None
    }
+    None
 }

 #[cfg(test)]
@@ -9,6 +9,8 @@ pub struct FileTypes {
    pub files: bool,
    pub directories: bool,
    pub symlinks: bool,
+    pub block_devices: bool,
+    pub char_devices: bool,
    pub sockets: bool,
    pub pipes: bool,
    pub executables_only: bool,
@@ -21,6 +23,8 @@ impl FileTypes {
            (!self.files && entry_type.is_file())
                || (!self.directories && entry_type.is_dir())
                || (!self.symlinks && entry_type.is_symlink())
+                || (!self.block_devices && filesystem::is_block_device(*entry_type))
+                || (!self.char_devices && filesystem::is_char_device(*entry_type))
                || (!self.sockets && filesystem::is_socket(*entry_type))
                || (!self.pipes && filesystem::is_pipe(*entry_type))
                || (self.executables_only && !entry.path().executable())
@@ -28,6 +32,8 @@ impl FileTypes {
                || !(entry_type.is_file()
                    || entry_type.is_dir()
                    || entry_type.is_symlink()
+                    || filesystem::is_block_device(*entry_type)
+                    || filesystem::is_char_device(*entry_type)
                    || filesystem::is_socket(*entry_type)
                    || filesystem::is_pipe(*entry_type))
        } else {
@@ -1,4 +1,5 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
+use nix::unistd::{Group, User};
 use std::fs;

 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -35,16 +36,22 @@ impl OwnerFilter {
        }

        let uid = Check::parse(fst, |s| {
-            s.parse()
-                .ok()
-                .or_else(|| users::get_user_by_name(s).map(|user| user.uid()))
-                .ok_or_else(|| anyhow!("'{}' is not a recognized user name", s))
+            if let Ok(uid) = s.parse() {
+                Ok(uid)
+            } else {
+                User::from_name(s)?
+                    .map(|user| user.uid.as_raw())
+                    .ok_or_else(|| anyhow!("'{}' is not a recognized user name", s))
+            }
        })?;
        let gid = Check::parse(snd, |s| {
-            s.parse()
-                .ok()
-                .or_else(|| users::get_group_by_name(s).map(|group| group.gid()))
-                .ok_or_else(|| anyhow!("'{}' is not a recognized group name", s))
+            if let Ok(gid) = s.parse() {
+                Ok(gid)
+            } else {
+                Group::from_name(s)?
+                    .map(|group| group.gid.as_raw())
+                    .ok_or_else(|| anyhow!("'{}' is not a recognized group name", s))
+            }
        })?;

        Ok(OwnerFilter { uid, gid })
@@ -1,6 +1,6 @@
-use chrono::{offset::TimeZone, DateTime, Local, NaiveDate};
+use jiff::{Span, Timestamp, Zoned, civil::DateTime, tz::TimeZone};

-use std::time::SystemTime;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};

 /// Filter based on time ranges.
 #[derive(Debug, PartialEq, Eq)]
@@ -9,32 +9,49 @@ pub enum TimeFilter {
    After(SystemTime),
 }

+#[cfg(not(test))]
+fn now() -> Zoned {
+    Zoned::now()
+}
+
+#[cfg(test)]
+thread_local! {
+    static TESTTIME: std::cell::RefCell<Option<Zoned>> = None.into();
+}
+
+/// This allows us to set a specific time when running tests
+#[cfg(test)]
+fn now() -> Zoned {
+    TESTTIME.with_borrow(|reftime| reftime.as_ref().cloned().unwrap_or_else(Zoned::now))
+}
+
 impl TimeFilter {
-    fn from_str(ref_time: &SystemTime, s: &str) -> Option<SystemTime> {
-        humantime::parse_duration(s)
-            .map(|duration| *ref_time - duration)
-            .ok()
-            .or_else(|| {
-                DateTime::parse_from_rfc3339(s)
-                    .map(|dt| dt.into())
-                    .ok()
-                    .or_else(|| {
-                        NaiveDate::parse_from_str(s, "%F")
-                            .ok()
-                            .and_then(|nd| nd.and_hms_opt(0, 0, 0))
-                            .and_then(|ndt| Local.from_local_datetime(&ndt).single())
-                    })
-                    .or_else(|| Local.datetime_from_str(s, "%F %T").ok())
-                    .map(|dt| dt.into())
-            })
+    fn from_str(s: &str) -> Option<SystemTime> {
+        if let Ok(span) = s.parse::<Span>() {
+            let datetime = now().checked_sub(span).ok()?;
+            Some(datetime.into())
+        } else if let Ok(timestamp) = s.parse::<Timestamp>() {
+            Some(timestamp.into())
+        } else if let Ok(datetime) = s.parse::<DateTime>() {
+            Some(
+                TimeZone::system()
+                    .to_ambiguous_zoned(datetime)
+                    .later()
+                    .ok()?
+                    .into(),
+            )
+        } else {
+            let timestamp_secs: u64 = s.strip_prefix('@')?.parse().ok()?;
+            UNIX_EPOCH.checked_add(Duration::from_secs(timestamp_secs))
+        }
    }

-    pub fn before(ref_time: &SystemTime, s: &str) -> Option<TimeFilter> {
-        TimeFilter::from_str(ref_time, s).map(TimeFilter::Before)
+    pub fn before(s: &str) -> Option<TimeFilter> {
+        TimeFilter::from_str(s).map(TimeFilter::Before)
    }

-    pub fn after(ref_time: &SystemTime, s: &str) -> Option<TimeFilter> {
-        TimeFilter::from_str(ref_time, s).map(TimeFilter::After)
+    pub fn after(s: &str) -> Option<TimeFilter> {
+        TimeFilter::from_str(s).map(TimeFilter::After)
    }

    pub fn applies_to(&self, t: &SystemTime) -> bool {
@@ -50,82 +67,144 @@ mod tests {
    use super::*;
    use std::time::Duration;

+    struct TestTime(SystemTime);
+
+    impl TestTime {
+        fn new(time: Zoned) -> Self {
+            TESTTIME.with_borrow_mut(|t| *t = Some(time.clone()));
+            TestTime(time.into())
+        }
+
+        fn set(&mut self, time: Zoned) {
+            TESTTIME.with_borrow_mut(|t| *t = Some(time.clone()));
+            self.0 = time.into();
+        }
+
+        fn timestamp(&self) -> SystemTime {
+            self.0
+        }
+    }
+
+    impl Drop for TestTime {
+        fn drop(&mut self) {
+            // Stop using manually set times
+            TESTTIME.with_borrow_mut(|t| *t = None);
+        }
+    }
+
    #[test]
    fn is_time_filter_applicable() {
-        let ref_time = Local
-            .datetime_from_str("2010-10-10 10:10:10", "%F %T")
-            .unwrap()
-            .into();
+        let local_tz = TimeZone::system();
+        let mut test_time = TestTime::new(
+            local_tz
+                .to_ambiguous_zoned("2010-10-10 10:10:10".parse::<DateTime>().unwrap())
+                .later()
+                .unwrap(),
+        );
+        let mut ref_time = test_time.timestamp();

-        assert!(TimeFilter::after(&ref_time, "1min")
-            .unwrap()
-            .applies_to(&ref_time));
-        assert!(!TimeFilter::before(&ref_time, "1min")
-            .unwrap()
-            .applies_to(&ref_time));
+        assert!(TimeFilter::after("1min").unwrap().applies_to(&ref_time));
+        assert!(!TimeFilter::before("1min").unwrap().applies_to(&ref_time));

        let t1m_ago = ref_time - Duration::from_secs(60);
-        assert!(!TimeFilter::after(&ref_time, "30sec")
-            .unwrap()
-            .applies_to(&t1m_ago));
-        assert!(TimeFilter::after(&ref_time, "2min")
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(!TimeFilter::after("30sec").unwrap().applies_to(&t1m_ago));
+        assert!(TimeFilter::after("2min").unwrap().applies_to(&t1m_ago));

-        assert!(TimeFilter::before(&ref_time, "30sec")
-            .unwrap()
-            .applies_to(&t1m_ago));
-        assert!(!TimeFilter::before(&ref_time, "2min")
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(TimeFilter::before("30sec").unwrap().applies_to(&t1m_ago));
+        assert!(!TimeFilter::before("2min").unwrap().applies_to(&t1m_ago));

        let t10s_before = "2010-10-10 10:10:00";
-        assert!(!TimeFilter::before(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&ref_time));
-        assert!(TimeFilter::before(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(
+            !TimeFilter::before(t10s_before)
+                .unwrap()
+                .applies_to(&ref_time)
+        );
+        assert!(
+            TimeFilter::before(t10s_before)
+                .unwrap()
+                .applies_to(&t1m_ago)
+        );

-        assert!(TimeFilter::after(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&ref_time));
-        assert!(!TimeFilter::after(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(
+            TimeFilter::after(t10s_before)
+                .unwrap()
+                .applies_to(&ref_time)
+        );
+        assert!(!TimeFilter::after(t10s_before).unwrap().applies_to(&t1m_ago));

        let same_day = "2010-10-10";
-        assert!(!TimeFilter::before(&ref_time, same_day)
-            .unwrap()
-            .applies_to(&ref_time));
-        assert!(!TimeFilter::before(&ref_time, same_day)
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(!TimeFilter::before(same_day).unwrap().applies_to(&ref_time));
+        assert!(!TimeFilter::before(same_day).unwrap().applies_to(&t1m_ago));

-        assert!(TimeFilter::after(&ref_time, same_day)
-            .unwrap()
-            .applies_to(&ref_time));
-        assert!(TimeFilter::after(&ref_time, same_day)
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(TimeFilter::after(same_day).unwrap().applies_to(&ref_time));
+        assert!(TimeFilter::after(same_day).unwrap().applies_to(&t1m_ago));

-        let ref_time = DateTime::parse_from_rfc3339("2010-10-10T10:10:10+00:00")
-            .unwrap()
-            .into();
+        test_time.set(
+            "2010-10-10T10:10:10+00:00"
+                .parse::<Timestamp>()
+                .unwrap()
+                .to_zoned(local_tz.clone()),
+        );
+        ref_time = test_time.timestamp();
        let t1m_ago = ref_time - Duration::from_secs(60);
        let t10s_before = "2010-10-10T10:10:00+00:00";
-        assert!(!TimeFilter::before(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&ref_time));
-        assert!(TimeFilter::before(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(
+            !TimeFilter::before(t10s_before)
+                .unwrap()
+                .applies_to(&ref_time)
+        );
+        assert!(
+            TimeFilter::before(t10s_before)
+                .unwrap()
+                .applies_to(&t1m_ago)
+        );

-        assert!(TimeFilter::after(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&ref_time));
-        assert!(!TimeFilter::after(&ref_time, t10s_before)
-            .unwrap()
-            .applies_to(&t1m_ago));
+        assert!(
+            TimeFilter::after(t10s_before)
+                .unwrap()
+                .applies_to(&ref_time)
+        );
+        assert!(!TimeFilter::after(t10s_before).unwrap().applies_to(&t1m_ago));
+
+        let ref_timestamp = 1707723412u64; // Mon Feb 12 07:36:52 UTC 2024
+        test_time.set(
+            "2024-02-12T07:36:52+00:00"
+                .parse::<Timestamp>()
+                .unwrap()
+                .to_zoned(local_tz),
+        );
+        ref_time = test_time.timestamp();
+        let t1m_ago = ref_time - Duration::from_secs(60);
+        let t1s_later = ref_time + Duration::from_secs(1);
+        // Timestamp only supported via '@' prefix
+        assert!(TimeFilter::before(&ref_timestamp.to_string()).is_none());
+        assert!(
+            TimeFilter::before(&format!("@{ref_timestamp}"))
+                .unwrap()
+                .applies_to(&t1m_ago)
+        );
+        assert!(
+            !TimeFilter::before(&format!("@{ref_timestamp}"))
+                .unwrap()
+                .applies_to(&t1s_later)
+        );
+        assert!(
+            !TimeFilter::after(&format!("@{ref_timestamp}"))
+                .unwrap()
+                .applies_to(&t1m_ago)
+        );
+        assert!(
+            TimeFilter::after(&format!("@{ref_timestamp}"))
+                .unwrap()
+                .applies_to(&t1s_later)
+        );
+    }
+
+    #[test]
+    fn out_of_range_unix_timestamp_is_rejected() {
+        // A '@' timestamp large enough to overflow SystemTime must return
+        // None rather than panicking.
+        assert!(TimeFilter::before(&format!("@{}", u64::MAX)).is_none());
+        assert!(TimeFilter::after(&format!("@{}", u64::MAX)).is_none());
    }
 }
@@ -34,10 +34,10 @@ pub fn dirname(path: &Path) -> OsString {
 #[cfg(test)]
 mod path_tests {
    use super::*;
-    use std::path::MAIN_SEPARATOR;
+    use std::path::MAIN_SEPARATOR_STR;

    fn correct(input: &str) -> String {
-        input.replace('/', &MAIN_SEPARATOR.to_string())
+        input.replace('/', MAIN_SEPARATOR_STR)
    }

    macro_rules! func_tests {
@@ -0,0 +1,281 @@
+mod input;
+
+use std::borrow::Cow;
+use std::ffi::{OsStr, OsString};
+use std::fmt::{self, Display, Formatter};
+use std::path::{Component, Path, Prefix};
+use std::sync::OnceLock;
+
+use aho_corasick::AhoCorasick;
+
+use self::input::{basename, dirname, remove_extension};
+
+/// Designates what should be written to a buffer
+///
+/// Each `Token` contains either text, or a placeholder variant, which will be used to generate
+/// commands after all tokens for a given command template have been collected.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Token {
+    Placeholder,
+    Basename,
+    Parent,
+    NoExt,
+    BasenameNoExt,
+    Text(String),
+}
+
+impl Display for Token {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match *self {
+            Token::Placeholder => f.write_str("{}")?,
+            Token::Basename => f.write_str("{/}")?,
+            Token::Parent => f.write_str("{//}")?,
+            Token::NoExt => f.write_str("{.}")?,
+            Token::BasenameNoExt => f.write_str("{/.}")?,
+            Token::Text(ref string) => f.write_str(string)?,
+        }
+        Ok(())
+    }
+}
+
+/// A parsed format string
+///
+/// This is either a collection of `Token`s including at least one placeholder variant,
+/// or a fixed text.
+#[derive(Clone, Debug, PartialEq)]
+pub enum FormatTemplate {
+    Tokens(Vec<Token>),
+    Text(String),
+}
+
+static PLACEHOLDERS: OnceLock<AhoCorasick> = OnceLock::new();
+
+impl FormatTemplate {
+    pub fn has_tokens(&self) -> bool {
+        matches!(self, FormatTemplate::Tokens(_))
+    }
+
+    pub fn parse(fmt: &str) -> Self {
+        // NOTE: we assume that { and } have the same length
+        const BRACE_LEN: usize = '{'.len_utf8();
+        let mut tokens = Vec::new();
+        let mut remaining = fmt;
+        let mut buf = String::new();
+        let placeholders = PLACEHOLDERS.get_or_init(|| {
+            AhoCorasick::new(["{{", "}}", "{}", "{/}", "{//}", "{.}", "{/.}"]).unwrap()
+        });
+        while let Some(m) = placeholders.find(remaining) {
+            match m.pattern().as_u32() {
+                0 | 1 => {
+                    // we found an escaped {{ or }}, so add
+                    // everything up to the first char to the buffer
+                    // then skip the second one.
+                    buf += &remaining[..m.start() + BRACE_LEN];
+                    remaining = &remaining[m.end()..];
+                }
+                id if !remaining[m.end()..].starts_with('}') => {
+                    buf += &remaining[..m.start()];
+                    if !buf.is_empty() {
+                        tokens.push(Token::Text(std::mem::take(&mut buf)));
+                    }
+                    tokens.push(token_from_pattern_id(id));
+                    remaining = &remaining[m.end()..];
+                }
+                _ => {
+                    // We got a normal pattern, but the final "}"
+                    // is escaped, so add up to that to the buffer, then
+                    // skip the final }
+                    buf += &remaining[..m.end()];
+                    remaining = &remaining[m.end() + BRACE_LEN..];
+                }
+            }
+        }
+        // Add the rest of the string to the buffer, and add the final buffer to the tokens
+        if !remaining.is_empty() {
+            buf += remaining;
+        }
+        if tokens.is_empty() {
+            // No placeholders were found, so just return the text
+            return FormatTemplate::Text(buf);
+        }
+        // Add final text segment
+        if !buf.is_empty() {
+            tokens.push(Token::Text(buf));
+        }
+        debug_assert!(!tokens.is_empty());
+        FormatTemplate::Tokens(tokens)
+    }
+
+    /// Generate a result string from this template. If path_separator is Some, then it will replace
+    /// the path separator in all placeholder tokens. Fixed text and tokens are not affected by
+    /// path separator substitution.
+    pub fn generate(&self, path: impl AsRef<Path>, path_separator: Option<&str>) -> OsString {
+        use Token::*;
+        let path = path.as_ref();
+
+        match *self {
+            Self::Tokens(ref tokens) => {
+                let mut s = OsString::new();
+                for token in tokens {
+                    match token {
+                        Basename => s.push(Self::replace_separator(basename(path), path_separator)),
+                        BasenameNoExt => s.push(Self::replace_separator(
+                            &remove_extension(basename(path).as_ref()),
+                            path_separator,
+                        )),
+                        NoExt => s.push(Self::replace_separator(
+                            &remove_extension(path),
+                            path_separator,
+                        )),
+                        Parent => s.push(Self::replace_separator(&dirname(path), path_separator)),
+                        Placeholder => {
+                            s.push(Self::replace_separator(path.as_ref(), path_separator))
+                        }
+                        Text(string) => s.push(string),
+                    }
+                }
+                s
+            }
+            Self::Text(ref text) => OsString::from(text),
+        }
+    }
+
+    /// Replace the path separator in the input with the custom separator string. If path_separator
+    /// is None, simply return a borrowed Cow<OsStr> of the input. Otherwise, the input is
+    /// interpreted as a Path and its components are iterated through and re-joined into a new
+    /// OsString.
+    fn replace_separator<'a>(path: &'a OsStr, path_separator: Option<&str>) -> Cow<'a, OsStr> {
+        // fast-path - no replacement necessary
+        if path_separator.is_none() {
+            return Cow::Borrowed(path);
+        }
+
+        let path_separator = path_separator.unwrap();
+        let mut out = OsString::with_capacity(path.len());
+        let mut components = Path::new(path).components().peekable();
+
+        while let Some(comp) = components.next() {
+            match comp {
+                // Absolute paths on Windows are tricky.  A Prefix component is usually a drive
+                // letter or UNC path, and is usually followed by RootDir. There are also
+                // "verbatim" prefixes beginning with "\\?\" that skip normalization. We choose to
+                // ignore verbatim path prefixes here because they're very rare, might be
+                // impossible to reach here, and there's no good way to deal with them. If users
+                // are doing something advanced involving verbatim windows paths, they can do their
+                // own output filtering with a tool like sed.
+                Component::Prefix(prefix) => {
+                    if let Prefix::UNC(server, share) = prefix.kind() {
+                        // Prefix::UNC is a parsed version of '\\server\share'
+                        out.push(path_separator);
+                        out.push(path_separator);
+                        out.push(server);
+                        out.push(path_separator);
+                        out.push(share);
+                    } else {
+                        // All other Windows prefix types are rendered as-is. This results in e.g. "C:" for
+                        // drive letters. DeviceNS and Verbatim* prefixes won't have backslashes converted,
+                        // but they're not returned by directories fd can search anyway so we don't worry
+                        // about them.
+                        out.push(comp.as_os_str());
+                    }
+                }
+
+                // Root directory is always replaced with the custom separator.
+                Component::RootDir => out.push(path_separator),
+
+                // Everything else is joined normally, with a trailing separator if we're not last
+                _ => {
+                    out.push(comp.as_os_str());
+                    if components.peek().is_some() {
+                        out.push(path_separator);
+                    }
+                }
+            }
+        }
+        Cow::Owned(out)
+    }
+}
+
+// Convert the id from an aho-corasick match to the
+// appropriate token
+fn token_from_pattern_id(id: u32) -> Token {
+    use Token::*;
+    match id {
+        2 => Placeholder,
+        3 => Basename,
+        4 => Parent,
+        5 => NoExt,
+        6 => BasenameNoExt,
+        _ => unreachable!(),
+    }
+}
+
+#[cfg(test)]
+mod fmt_tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn parse_no_placeholders() {
+        let templ = FormatTemplate::parse("This string has no placeholders");
+        assert_eq!(
+            templ,
+            FormatTemplate::Text("This string has no placeholders".into())
+        );
+    }
+
+    #[test]
+    fn parse_only_brace_escapes() {
+        let templ = FormatTemplate::parse("This string only has escapes like {{ and }}");
+        assert_eq!(
+            templ,
+            FormatTemplate::Text("This string only has escapes like { and }".into())
+        );
+    }
+
+    #[test]
+    fn all_placeholders() {
+        use Token::*;
+
+        let templ = FormatTemplate::parse(
+            "{{path={} \
+            basename={/} \
+            parent={//} \
+            noExt={.} \
+            basenameNoExt={/.} \
+            }}",
+        );
+        assert_eq!(
+            templ,
+            FormatTemplate::Tokens(vec![
+                Text("{path=".into()),
+                Placeholder,
+                Text(" basename=".into()),
+                Basename,
+                Text(" parent=".into()),
+                Parent,
+                Text(" noExt=".into()),
+                NoExt,
+                Text(" basenameNoExt=".into()),
+                BasenameNoExt,
+                Text(" }".into()),
+            ])
+        );
+
+        let mut path = PathBuf::new();
+        path.push("a");
+        path.push("folder");
+        path.push("file.txt");
+
+        let expanded = templ.generate(&path, Some("/")).into_string().unwrap();
+
+        assert_eq!(
+            expanded,
+            "{path=a/folder/file.txt \
+            basename=file.txt \
+            parent=a/folder \
+            noExt=a/folder/file \
+            basenameNoExt=file }"
+        );
+    }
+}
@@ -0,0 +1,87 @@
+use crate::filesystem::absolute_path;
+use std::fmt::{self, Formatter, Write};
+use std::path::{Path, PathBuf};
+
+pub(crate) struct PathUrl(PathBuf);
+
+impl PathUrl {
+    pub(crate) fn new(path: &Path) -> Option<PathUrl> {
+        Some(PathUrl(absolute_path(path).ok()?))
+    }
+}
+
+impl fmt::Display for PathUrl {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "file://{}", host())?;
+        let bytes = self.0.as_os_str().as_encoded_bytes();
+        for &byte in bytes.iter() {
+            encode(f, byte)?;
+        }
+        Ok(())
+    }
+}
+
+fn encode(f: &mut Formatter, byte: u8) -> fmt::Result {
+    // NOTE:
+    // Most terminals can handle non-ascii unicode characters in a file url fine. But on some OSes (notably
+    // windows), the encoded bytes of the path may not be valid UTF-8. Since we don't know if a
+    // byte >= 128 is part of a valid UTF-8 encoding or not, we just percent encode any non-ascii
+    // byte.
+    // Percent encoding these bytes is probably safer anyway.
+    match byte {
+        b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z' | b'/' | b':' | b'-' | b'.' | b'_' | b'~' => {
+            f.write_char(byte.into())
+        }
+        #[cfg(windows)]
+        b'\\' => f.write_char('/'),
+        _ => {
+            write!(f, "%{byte:02X}")
+        }
+    }
+}
+
+#[cfg(unix)]
+fn host() -> &'static str {
+    use std::sync::OnceLock;
+
+    static HOSTNAME: OnceLock<String> = OnceLock::new();
+
+    HOSTNAME
+        .get_or_init(|| {
+            nix::unistd::gethostname()
+                .ok()
+                .and_then(|h| h.into_string().ok())
+                .unwrap_or_default()
+        })
+        .as_ref()
+}
+
+#[cfg(not(unix))]
+const fn host() -> &'static str {
+    "/"
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    // This allows us to test the encoding without having to worry about the host, or absolute path
+    struct Encoded(&'static str);
+
+    impl fmt::Display for Encoded {
+        fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+            for byte in self.0.bytes() {
+                encode(f, byte)?;
+            }
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn test_unicode_encoding() {
+        assert_eq!(
+            Encoded("$*\x1bßé/∫😃\x07").to_string(),
+            "%24%2A%1B%C3%9F%C3%A9/%E2%88%AB%F0%9F%98%83%07",
+        );
+    }
+}
@@ -7,23 +7,25 @@ mod exit_codes;
 mod filesystem;
 mod filetypes;
 mod filter;
+mod fmt;
+mod hyperlink;
 mod output;
 mod regex_helper;
+mod sanitize;
 mod walk;

 use std::env;
 use std::io::IsTerminal;
 use std::path::Path;
 use std::sync::Arc;
-use std::time;

-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use clap::{CommandFactory, Parser};
 use globset::GlobBuilder;
 use lscolors::LsColors;
 use regex::bytes::{Regex, RegexBuilder, RegexSetBuilder};

-use crate::cli::{ColorWhen, Opts};
+use crate::cli::{ColorWhen, HyperlinkWhen, Opts};
 use crate::config::Config;
 use crate::exec::CommandSet;
 use crate::exit_codes::ExitCode;
@@ -35,18 +37,21 @@ use crate::regex_helper::{pattern_has_uppercase_char, pattern_matches_strings_wi

 // We use jemalloc for performance reasons, see https://github.com/sharkdp/fd/pull/481
 // FIXME: re-enable jemalloc on macOS, see comment in Cargo.toml file for more infos
+// This has to be kept in sync with the Cargo.toml file section that declares a
+// dependency on tikv-jemallocator.
 #[cfg(all(
    not(windows),
    not(target_os = "android"),
    not(target_os = "macos"),
    not(target_os = "freebsd"),
    not(target_os = "openbsd"),
+    not(target_os = "illumos"),
    not(all(target_env = "musl", target_pointer_width = "32")),
    not(target_arch = "riscv64"),
    feature = "use-jemalloc"
 ))]
 #[global_allocator]
-static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
+static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;

 // vivid --color-mode 8-bit generate molokai
 const DEFAULT_LS_COLORS: &str = "
@@ -61,7 +66,7 @@ fn main() {
            exit_code.exit();
        }
        Err(err) => {
-            eprintln!("[fd error]: {:#}", err);
+            crate::error::print_error(format!("{err:#}"));
            ExitCode::GeneralError.exit();
        }
    }
@@ -103,7 +108,7 @@ fn run() -> Result<ExitCode> {
        .map(|pat| build_regex(pat, &config))
        .collect::<Result<Vec<Regex>>>()?;

-    walk::scan(&search_paths, Arc::new(regexps), Arc::new(config))
+    walk::scan(&search_paths, regexps, config)
 }

 #[cfg(feature = "completions")]
@@ -141,21 +146,69 @@ fn set_working_dir(opts: &Opts) -> Result<()> {
    Ok(())
 }

-/// Detect if the user accidentally supplied a path instead of a search pattern
+/// Detect if the user accidentally supplied a path instead of a search pattern.
+///
+/// Without `--full-path`, fd matches patterns against file names, so any pattern
+/// containing a path separator can never match. This applies to the primary
+/// positional pattern *and* to every `--and` pattern, since all of them are
+/// chained together and matched against the file name (see `run`). Two cases per
+/// pattern are worth a friendly error rather than silent "no results":
+///
+/// 1. The pattern contains '/'. '/' is always a path separator (including on
+///    Windows) and has no regex meaning, so flagging it is safe and catches the
+///    common Linux/macOS mistake of pasting a full path as the pattern.
+/// 2. On Windows only, the pattern contains the native `\` separator *and*
+///    names an existing directory on disk. We can't treat `\` as a pure
+///    path-separator signal there because it is also the regex escape char,
+///    so valid regex patterns like `\Ac` or `\d+` must still run. Requiring
+///    that the pattern resolves to a real directory avoids those false
+///    positives while preserving the legacy diagnostic for operators who
+///    literally typed a directory path.
+///
+/// See https://github.com/sharkdp/fd/issues/1873.
 fn ensure_search_pattern_is_not_a_path(opts: &Opts) -> Result<()> {
-    if !opts.full_path
-        && opts.pattern.contains(std::path::MAIN_SEPARATOR)
-        && Path::new(&opts.pattern).is_dir()
+    if opts.full_path {
+        return Ok(());
+    }
+
+    // Check the primary pattern and every `--and` pattern. They are all matched
+    // against the file name (see `run`), so a path separator in any of them is
+    // the same silent "no results" footgun.
+    for pattern in std::iter::once(&opts.pattern).chain(opts.exprs.iter().flatten()) {
+        ensure_single_search_pattern_is_not_a_path(pattern)?;
+    }
+    Ok(())
+}
+
+/// Apply the path-separator diagnostic to a single pattern. See
+/// [`ensure_search_pattern_is_not_a_path`] for the rationale of each case.
+fn ensure_single_search_pattern_is_not_a_path(pattern: &str) -> Result<()> {
+    // Start with the cheap check: '/' is always a path separator, including on
+    // Windows, and has no regex meaning, so flagging it is safe and catches the
+    // Linux/macOS mistake of pasting a full path as the pattern.
+    #[cfg_attr(not(windows), allow(unused_mut))]
+    let mut should_warn = pattern.contains('/');
+
+    // On Windows we additionally accept the native `\` separator, but only when
+    // the pattern actually resolves to an existing directory - `\` is also the
+    // regex escape char there, so valid patterns like `\Ac` or `\d+` must still
+    // run. The is_dir syscall is only needed when `should_warn` is still false,
+    // so short-circuit via `||` to avoid the stat call on the happy path.
+    #[cfg(windows)]
    {
+        should_warn = should_warn
+            || (pattern.contains(std::path::MAIN_SEPARATOR) && Path::new(pattern).is_dir());
+    }
+
+    if should_warn {
        Err(anyhow!(
-            "The search pattern '{pattern}' contains a path-separation character ('{sep}') \
+            "The search pattern '{pattern}' contains a path-separation character \
             and will not lead to any search results.\n\n\
             If you want to search for all files inside the '{pattern}' directory, use a match-all pattern:\n\n  \
             fd . '{pattern}'\n\n\
             Instead, if you want your pattern to match the full file path, use:\n\n  \
             fd --full-path '{pattern}'",
-            pattern = &opts.pattern,
-            sep = std::path::MAIN_SEPARATOR,
+            pattern = pattern,
        ))
    } else {
        Ok(())
@@ -166,6 +219,10 @@ fn build_pattern_regex(pattern: &str, opts: &Opts) -> Result<String> {
    Ok(if opts.glob && !pattern.is_empty() {
        let glob = GlobBuilder::new(pattern).literal_separator(true).build()?;
        glob.regex().to_owned()
+    } else if opts.exact {
+        // Anchor the escaped pattern so the full filename (or path) must match exactly.
+        // Literal. No substring matching.
+        format!("^{}$", regex::escape(pattern))
    } else if opts.fixed_strings {
        // Treat pattern as literal string if '--fixed-strings' is used
        regex::escape(pattern)
@@ -218,11 +275,13 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
    let ansi_colors_support = true;

    let interactive_terminal = std::io::stdout().is_terminal();
+
    let colored_output = match opts.color {
        ColorWhen::Always => true,
        ColorWhen::Never => false,
        ColorWhen::Auto => {
-            ansi_colors_support && env::var_os("NO_COLOR").is_none() && interactive_terminal
+            let no_color = env::var_os("NO_COLOR").is_some_and(|x| !x.is_empty());
+            ansi_colors_support && !no_color && interactive_terminal
        }
    };

@@ -231,12 +290,26 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
    } else {
        None
    };
+    let hyperlink = match opts.hyperlink {
+        HyperlinkWhen::Always => true,
+        HyperlinkWhen::Never => false,
+        HyperlinkWhen::Auto => colored_output,
+    };
    let command = extract_command(&mut opts, colored_output)?;
    let has_command = command.is_some();

+    let full_path_base = if opts.full_path {
+        Some(env::current_dir().context(
+            "Could not determine current directory. \
+             This is required for --full-path.",
+        )?)
+    } else {
+        None
+    };
+
    Ok(Config {
        case_sensitive,
-        search_full_path: opts.full_path,
+        full_path_base,
        ignore_hidden: !(opts.hidden || opts.rg_alias_ignore()),
        read_fdignore: !(opts.no_ignore || opts.rg_alias_ignore()),
        read_vcsignore: !(opts.no_ignore || opts.rg_alias_ignore() || opts.no_ignore_vcs),
@@ -252,9 +325,10 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
        max_depth: opts.max_depth(),
        min_depth: opts.min_depth(),
        prune: opts.prune,
-        threads: opts.threads(),
+        threads: opts.threads().get(),
        max_buffer_time: opts.max_buffer_time,
        ls_colors,
+        hyperlink,
        interactive_terminal,
        file_types: opts.filetype.as_ref().map(|values| {
            use crate::cli::FileType::*;
@@ -269,6 +343,8 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
                        file_types.files = true;
                    }
                    Empty => file_types.empty_only = true,
+                    BlockDevice => file_types.block_devices = true,
+                    CharDevice => file_types.char_devices = true,
                    Socket => file_types.sockets = true,
                    Pipe => file_types.pipes = true,
                }
@@ -295,6 +371,10 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
                    .build()
            })
            .transpose()?,
+        format: opts
+            .format
+            .as_deref()
+            .map(crate::fmt::FormatTemplate::parse),
        command: command.map(Arc::new),
        batch_size: opts.batch_size,
        exclude_patterns: opts.exclude.iter().map(|p| String::from("!") + p).collect(),
@@ -307,8 +387,8 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
        path_separator,
        actual_path_separator,
        max_results: opts.max_results(),
-        strip_cwd_prefix: (opts.no_search_paths()
-            && (opts.strip_cwd_prefix || !(opts.null_separator || has_command))),
+        strip_cwd_prefix: opts.strip_cwd_prefix(|| !(opts.null_separator || has_command)),
+        ignore_contain: opts.ignore_contain,
    })
 }

@@ -321,18 +401,22 @@ fn extract_command(opts: &mut Opts, colored_output: bool) -> Result<Option<Comma
            if !opts.list_details {
                return None;
            }
-            let color_arg = format!("--color={}", opts.color.as_str());

-            let res = determine_ls_command(&color_arg, colored_output)
+            let res = determine_ls_command(colored_output)
                .map(|cmd| CommandSet::new_batch([cmd]).unwrap());
            Some(res)
        })
        .transpose()
 }

-fn determine_ls_command(color_arg: &str, colored_output: bool) -> Result<Vec<&str>> {
+fn determine_ls_command(colored_output: bool) -> Result<Vec<&'static str>> {
    #[allow(unused)]
    let gnu_ls = |command_name| {
+        let color_arg = if colored_output {
+            "--color=always"
+        } else {
+            "--color=never"
+        };
        // Note: we use short options here (instead of --long-options) to support more
        // platforms (like BusyBox).
        vec![
@@ -354,7 +438,7 @@ fn determine_ls_command(color_arg: &str, colored_output: bool) -> Result<Vec<&st
            // Assume ls is GNU ls
            gnu_ls("ls")
        } else {
-            // MacOS, DragonFlyBSD, FreeBSD
+            // macOS, DragonFlyBSD, FreeBSD
            use std::process::{Command, Stdio};

            // Use GNU ls, if available (support for --color=auto, better LS_COLORS support)
@@ -410,10 +494,9 @@ fn determine_ls_command(color_arg: &str, colored_output: bool) -> Result<Vec<&st
 }

 fn extract_time_constraints(opts: &Opts) -> Result<Vec<TimeFilter>> {
-    let now = time::SystemTime::now();
    let mut time_constraints: Vec<TimeFilter> = Vec::new();
    if let Some(ref t) = opts.changed_within {
-        if let Some(f) = TimeFilter::after(&now, t) {
+        if let Some(f) = TimeFilter::after(t) {
            time_constraints.push(f);
        } else {
            return Err(anyhow!(
@@ -423,7 +506,7 @@ fn extract_time_constraints(opts: &Opts) -> Result<Vec<TimeFilter>> {
        }
    }
    if let Some(ref t) = opts.changed_before {
-        if let Some(f) = TimeFilter::before(&now, t) {
+        if let Some(f) = TimeFilter::before(t) {
            time_constraints.push(f);
        } else {
            return Err(anyhow!(
@@ -462,10 +545,11 @@ fn build_regex(pattern_regex: String, config: &Config) -> Result<regex::bytes::R
        .build()
        .map_err(|e| {
            anyhow!(
-                "{}\n\nNote: You can use the '--fixed-strings' option to search for a \
-                 literal string instead of a regular expression. Alternatively, you can \
+                "{}\n\nNote: You can search for literal substrings with '--fixed-strings' \
+                 or literal strings with '--exact' options (instead of a regular expression). \
+                 Alternatively, you can \
                 also use the '--glob' option to match on a glob pattern.",
-                e.to_string()
+                e
            )
        })
 }
@@ -5,29 +5,40 @@ use lscolors::{Indicator, LsColors, Style};

 use crate::config::Config;
 use crate::dir_entry::DirEntry;
-use crate::error::print_error;
-use crate::exit_codes::ExitCode;
+use crate::fmt::FormatTemplate;
+use crate::hyperlink::PathUrl;
+use crate::sanitize::maybe_sanitize;

 fn replace_path_separator(path: &str, new_path_separator: &str) -> String {
    path.replace(std::path::MAIN_SEPARATOR, new_path_separator)
 }

 // TODO: this function is performance critical and can probably be optimized
-pub fn print_entry<W: Write>(stdout: &mut W, entry: &DirEntry, config: &Config) {
-    let r = if let Some(ref ls_colors) = config.ls_colors {
-        print_entry_colorized(stdout, entry, config, ls_colors)
+pub fn print_entry<W: Write>(stdout: &mut W, entry: &DirEntry, config: &Config) -> io::Result<()> {
+    let mut has_hyperlink = false;
+    if config.hyperlink
+        && let Some(url) = PathUrl::new(entry.path())
+    {
+        write!(stdout, "\x1B]8;;{url}\x1B\\")?;
+        has_hyperlink = true;
+    }
+
+    if let Some(ref format) = config.format {
+        print_entry_format(stdout, entry, config, format)?;
+    } else if let Some(ref ls_colors) = config.ls_colors {
+        print_entry_colorized(stdout, entry, config, ls_colors)?;
    } else {
-        print_entry_uncolorized(stdout, entry, config)
+        print_entry_uncolorized(stdout, entry, config)?;
    };

-    if let Err(e) = r {
-        if e.kind() == ::std::io::ErrorKind::BrokenPipe {
-            // Exit gracefully in case of a broken pipe (e.g. 'fd ... | head -n 3').
-            ExitCode::Success.exit();
-        } else {
-            print_error(format!("Could not write to output: {}", e));
-            ExitCode::GeneralError.exit();
-        }
+    if has_hyperlink {
+        write!(stdout, "\x1B]8;;\x1B\\")?;
+    }
+
+    if config.null_separator {
+        write!(stdout, "\0")
+    } else {
+        writeln!(stdout)
    }
 }

@@ -41,7 +52,7 @@ fn print_trailing_slash<W: Write>(
    config: &Config,
    style: Option<&Style>,
 ) -> io::Result<()> {
-    if entry.file_type().map_or(false, |ft| ft.is_dir()) {
+    if entry.file_type().is_some_and(|ft| ft.is_dir()) {
        write!(
            stdout,
            "{}",
@@ -54,6 +65,26 @@ fn print_trailing_slash<W: Write>(
    Ok(())
 }

+// TODO: this function is performance critical and can probably be optimized
+fn print_entry_format<W: Write>(
+    stdout: &mut W,
+    entry: &DirEntry,
+    config: &Config,
+    format: &FormatTemplate,
+) -> io::Result<()> {
+    let output = format.generate(
+        entry.stripped_path(config),
+        config.path_separator.as_deref(),
+    );
+    // TODO: support writing raw bytes on unix?
+    let s = output.to_string_lossy();
+    write!(
+        stdout,
+        "{}",
+        maybe_sanitize(&s, config.interactive_terminal)
+    )
+}
+
 // TODO: this function is performance critical and can probably be optimized
 fn print_entry_colorized<W: Write>(
    stdout: &mut W,
@@ -61,7 +92,6 @@ fn print_entry_colorized<W: Write>(
    config: &Config,
    ls_colors: &LsColors,
 ) -> io::Result<()> {
-    // Split the path between the parent and the last component
    let mut offset = 0;
    let path = entry.stripped_path(config);
    let path_str = path.to_string_lossy();
@@ -87,14 +117,16 @@ fn print_entry_colorized<W: Write>(
            .style_for_indicator(Indicator::Directory)
            .map(Style::to_nu_ansi_term_style)
            .unwrap_or_default();
-        write!(stdout, "{}", style.paint(parent_str))?;
+        let safe_parent = maybe_sanitize(&parent_str, config.interactive_terminal);
+        write!(stdout, "{}", style.paint(safe_parent.as_ref()))?;
    }

    let style = entry
        .style(ls_colors)
        .map(Style::to_nu_ansi_term_style)
        .unwrap_or_default();
-    write!(stdout, "{}", style.paint(&path_str[offset..]))?;
+    let safe_basename = maybe_sanitize(&path_str[offset..], config.interactive_terminal);
+    write!(stdout, "{}", style.paint(safe_basename.as_ref()))?;

    print_trailing_slash(
        stdout,
@@ -103,12 +135,6 @@ fn print_entry_colorized<W: Write>(
        ls_colors.style_for_indicator(Indicator::Directory),
    )?;

-    if config.null_separator {
-        write!(stdout, "\0")?;
-    } else {
-        writeln!(stdout)?;
-    }
-
    Ok(())
 }

@@ -118,16 +144,15 @@ fn print_entry_uncolorized_base<W: Write>(
    entry: &DirEntry,
    config: &Config,
 ) -> io::Result<()> {
-    let separator = if config.null_separator { "\0" } else { "\n" };
    let path = entry.stripped_path(config);

    let mut path_string = path.to_string_lossy();
    if let Some(ref separator) = config.path_separator {
        *path_string.to_mut() = replace_path_separator(&path_string, separator);
    }
-    write!(stdout, "{}", path_string)?;
-    print_trailing_slash(stdout, entry, config, None)?;
-    write!(stdout, "{}", separator)
+    let safe = maybe_sanitize(&path_string, config.interactive_terminal);
+    write!(stdout, "{safe}")?;
+    print_trailing_slash(stdout, entry, config, None)
 }

 #[cfg(not(unix))]
@@ -148,13 +173,10 @@ fn print_entry_uncolorized<W: Write>(
    use std::os::unix::ffi::OsStrExt;

    if config.interactive_terminal || config.path_separator.is_some() {
-        // Fall back to the base implementation
        print_entry_uncolorized_base(stdout, entry, config)
    } else {
-        // Print path as raw bytes, allowing invalid UTF-8 filenames to be passed to other processes
-        let separator = if config.null_separator { b"\0" } else { b"\n" };
+        // Piped output: raw bytes so invalid UTF-8 filenames reach downstream tools intact.
        stdout.write_all(entry.stripped_path(config).as_os_str().as_bytes())?;
-        print_trailing_slash(stdout, entry, config, None)?;
-        stdout.write_all(separator)
+        print_trailing_slash(stdout, entry, config, None)
    }
 }
@@ -1,5 +1,5 @@
-use regex_syntax::hir::Hir;
 use regex_syntax::ParserBuilder;
+use regex_syntax::hir::Hir;

 /// Determine if a regex pattern contains a literal uppercase character.
 pub fn pattern_has_uppercase_char(pattern: &str) -> bool {
@@ -16,7 +16,7 @@ fn hir_has_uppercase_char(hir: &Hir) -> bool {
    use regex_syntax::hir::*;

    match hir.kind() {
-        HirKind::Literal(Literal(bytes)) => match std::str::from_utf8(&bytes) {
+        HirKind::Literal(Literal(bytes)) => match std::str::from_utf8(bytes) {
            Ok(s) => s.chars().any(|c| c.is_uppercase()),
            Err(_) => bytes.iter().any(|b| char::from(*b).is_uppercase()),
        },
@@ -67,7 +67,7 @@ fn hir_matches_strings_with_leading_dot(hir: &Hir) -> bool {

            if let Some(hir) = hirs.next() {
                match hir.kind() {
-                    HirKind::Literal(Literal(bytes)) => bytes.starts_with(&[b'.']),
+                    HirKind::Literal(Literal(bytes)) => bytes.starts_with(b"."),
                    _ => false,
                }
            } else {
@@ -0,0 +1,168 @@
+//! TTY-output sanitization to prevent terminal escape injection via filenames.
+
+use std::borrow::Cow;
+use std::fmt::Write;
+
+/// True for any char that is neither printable nor permitted whitespace (only HT).
+/// Covers C0/C1/DEL, bidi overrides, zero-width and format chars, and tag chars.
+#[inline]
+fn needs_escape(c: char) -> bool {
+    if c == '\t' {
+        return false;
+    }
+    c.is_control()
+        || matches!(c,
+            '\u{00AD}'                  // soft hyphen (invisible)
+            | '\u{180E}'                // Mongolian vowel separator
+            | '\u{200B}'..='\u{200F}'   // zero-width + LRM/RLM
+            | '\u{202A}'..='\u{202E}'   // bidi embedding/override
+            | '\u{2060}'..='\u{206F}'   // word joiner, invisibles, deprecated formats
+            | '\u{FEFF}'                // BOM / zero-width no-break space
+            | '\u{FFF9}'..='\u{FFFB}'   // interlinear annotation
+            | '\u{E0000}'..='\u{E007F}' // language tags
+        )
+}
+
+/// Returns a `Cow<str>` borrowing `s` when no escaping is needed, otherwise an owned
+/// escaped copy. Use this when an owned `&str`/`String` is required (e.g. ANSI paint).
+pub fn sanitize_for_terminal(s: &str) -> Cow<'_, str> {
+    if !s.chars().any(needs_escape) {
+        return Cow::Borrowed(s);
+    }
+    let mut out = String::with_capacity(s.len());
+    for c in s.chars() {
+        if needs_escape(c) {
+            let v = c as u32;
+            if v <= 0xFF {
+                let _ = write!(out, "\\x{v:02X}");
+            } else {
+                let _ = write!(out, "\\u{{{v:04X}}}");
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    Cow::Owned(out)
+}
+
+/// Sanitize for terminal output only; raw bytes pass through on pipes/files.
+pub fn maybe_sanitize<'a>(s: &'a str, is_terminal: bool) -> Cow<'a, str> {
+    if is_terminal {
+        sanitize_for_terminal(s)
+    } else {
+        Cow::Borrowed(s)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn preserves_safe_content() {
+        for s in [
+            "hello.txt",
+            "résumé.pdf",
+            "文档.txt",
+            "🦀.rs",
+            "a\tb",
+            "a\u{FFFD}b",
+        ] {
+            assert!(
+                matches!(sanitize_for_terminal(s), Cow::Borrowed(_)),
+                "{s:?}"
+            );
+            assert_eq!(sanitize_for_terminal(s), s);
+        }
+    }
+
+    #[test]
+    fn strips_osc52_clipboard_payload() {
+        let attack = "innocent\x1b]52;c;cHduZWQ=\x1b\\.txt";
+        let safe = sanitize_for_terminal(attack);
+        assert!(!safe.contains('\x1b'));
+        assert_eq!(safe, "innocent\\x1B]52;c;cHduZWQ=\\x1B\\.txt");
+    }
+
+    #[test]
+    fn strips_cr_output_forgery() {
+        assert_eq!(sanitize_for_terminal("A\rFAKE OUTPUT"), "A\\x0DFAKE OUTPUT");
+    }
+
+    #[test]
+    fn strips_osc8_hyperlink_injection() {
+        let attack = "phish\x1b]8;;https:evil.example\x1b\\phony.txt";
+        assert!(!sanitize_for_terminal(attack).contains('\x1b'));
+    }
+
+    #[test]
+    fn strips_del() {
+        assert_eq!(sanitize_for_terminal("a\x7fb"), "a\\x7Fb");
+    }
+
+    #[test]
+    fn strips_bel_and_null() {
+        assert_eq!(sanitize_for_terminal("a\x07b"), "a\\x07b");
+        assert_eq!(sanitize_for_terminal("a\0b"), "a\\x00b");
+    }
+
+    #[test]
+    fn strips_newline() {
+        assert_eq!(sanitize_for_terminal("a\nb"), "a\\x0Ab");
+    }
+
+    #[test]
+    fn escape_preserves_information() {
+        let s = "name\x1bX\x07Y.txt";
+        assert_eq!(sanitize_for_terminal(s), "name\\x1BX\\x07Y.txt");
+    }
+
+    #[test]
+    fn strips_c1_csi_and_osc_initiators() {
+        // U+009B is CSI, U+009D is OSC; dangerous on 8-bit-control terminals.
+        assert_eq!(sanitize_for_terminal("\u{9b}31m"), "\\x9B31m");
+        assert_eq!(
+            sanitize_for_terminal("\u{9d}0;pwned\u{9c}"),
+            "\\x9D0;pwned\\x9C"
+        );
+    }
+
+    #[test]
+    fn strips_bidi_overrides_and_zero_width() {
+        // Trojan-Source style RLO/LRO that flip rendered order of filename text.
+        assert_eq!(
+            sanitize_for_terminal("safe\u{202E}fil\u{202D}gnp.exe"),
+            "safe\\u{202E}fil\\u{202D}gnp.exe"
+        );
+        // Zero-width space and BOM are also format chars used to disguise filenames.
+        assert_eq!(sanitize_for_terminal("a\u{200B}b"), "a\\u{200B}b");
+        assert_eq!(sanitize_for_terminal("\u{FEFF}name"), "\\u{FEFF}name");
+    }
+
+    #[test]
+    fn keeps_legitimate_unicode_features() {
+        // Variation selectors (U+FE0F, U+E0100..) modify preceding glyphs in CJK/emoji
+        // and are legitimate in filenames. Private-use chars are used by icon fonts.
+        for s in [
+            "heart\u{2764}\u{FE0F}.txt",
+            "icon\u{E000}.cfg",
+            "cjk\u{6F22}\u{E0101}.txt",
+        ] {
+            assert!(
+                matches!(sanitize_for_terminal(s), Cow::Borrowed(_)),
+                "{s:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn maybe_sanitize_passthrough_when_not_terminal() {
+        let attack = "x\x1by";
+        // Pipe context: bytes pass through unchanged (zero-copy).
+        let out = maybe_sanitize(attack, false);
+        assert!(matches!(out, Cow::Borrowed(_)));
+        assert_eq!(out, attack);
+        // TTY context: escapes apply.
+        assert_eq!(maybe_sanitize(attack, true), "x\\x1By");
+    }
+}
@@ -1,25 +1,25 @@
+use std::borrow::Cow;
 use std::ffi::OsStr;
-use std::io;
+use std::io::{self, Write};
 use std::mem;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, MutexGuard};
 use std::thread;
 use std::time::{Duration, Instant};
-use std::{borrow::Cow, io::Write};

-use anyhow::{anyhow, Result};
-use crossbeam_channel::{bounded, Receiver, RecvTimeoutError, Sender};
+use anyhow::{Result, anyhow};
+use crossbeam_channel::{Receiver, RecvTimeoutError, SendError, Sender, bounded};
 use etcetera::BaseStrategy;
-use ignore::overrides::OverrideBuilder;
-use ignore::{self, WalkBuilder};
+use ignore::overrides::{Override, OverrideBuilder};
+use ignore::{WalkBuilder, WalkParallel, WalkState};
 use regex::bytes::Regex;

 use crate::config::Config;
 use crate::dir_entry::DirEntry;
 use crate::error::print_error;
 use crate::exec;
-use crate::exit_codes::{merge_exitcodes, ExitCode};
+use crate::exit_codes::{ExitCode, merge_exitcodes};
 use crate::filesystem;
 use crate::output;

@@ -36,6 +36,7 @@ enum ReceiverMode {

 /// The Worker threads can result in a valid entry having PathBuf or an error.
 #[allow(clippy::large_enum_variant)]
+#[derive(Debug)]
 pub enum WorkerResult {
    // Errors should be rare, so it's probably better to allow large_enum_variant than
    // to box the Entry variant
@@ -43,131 +44,98 @@ pub enum WorkerResult {
    Error(ignore::Error),
 }

-/// Maximum size of the output buffer before flushing results to the console
-pub const MAX_BUFFER_LENGTH: usize = 1000;
-/// Default duration until output buffering switches to streaming.
-pub const DEFAULT_MAX_BUFFER_TIME: Duration = Duration::from_millis(100);
+/// A batch of WorkerResults to send over a channel.
+#[derive(Clone)]
+struct Batch {
+    items: Arc<Mutex<Option<Vec<WorkerResult>>>>,
+}

-/// Recursively scan the given search path for files / pathnames matching the patterns.
-///
-/// If the `--exec` argument was supplied, this will create a thread pool for executing
-/// jobs in parallel from a given command line and the discovered paths. Otherwise, each
-/// path will simply be written to standard output.
-pub fn scan(paths: &[PathBuf], patterns: Arc<Vec<Regex>>, config: Arc<Config>) -> Result<ExitCode> {
-    let first_path = &paths[0];
-
-    // Channel capacity was chosen empircally to perform similarly to an unbounded channel
-    let (tx, rx) = bounded(0x4000 * config.threads);
-
-    let mut override_builder = OverrideBuilder::new(first_path);
-
-    for pattern in &config.exclude_patterns {
-        override_builder
-            .add(pattern)
-            .map_err(|e| anyhow!("Malformed exclude pattern: {}", e))?;
-    }
-    let overrides = override_builder
-        .build()
-        .map_err(|_| anyhow!("Mismatch in exclude patterns"))?;
-
-    let mut walker = WalkBuilder::new(first_path);
-    walker
-        .hidden(config.ignore_hidden)
-        .ignore(config.read_fdignore)
-        .parents(config.read_parent_ignore && (config.read_fdignore || config.read_vcsignore))
-        .git_ignore(config.read_vcsignore)
-        .git_global(config.read_vcsignore)
-        .git_exclude(config.read_vcsignore)
-        .require_git(config.require_git_to_read_vcsignore)
-        .overrides(overrides)
-        .follow_links(config.follow_links)
-        // No need to check for supported platforms, option is unavailable on unsupported ones
-        .same_file_system(config.one_file_system)
-        .max_depth(config.max_depth);
-
-    if config.read_fdignore {
-        walker.add_custom_ignore_filename(".fdignore");
-    }
-
-    if config.read_global_ignore {
-        if let Ok(basedirs) = etcetera::choose_base_strategy() {
-            let global_ignore_file = basedirs.config_dir().join("fd").join("ignore");
-            if global_ignore_file.is_file() {
-                let result = walker.add_ignore(global_ignore_file);
-                match result {
-                    Some(ignore::Error::Partial(_)) => (),
-                    Some(err) => {
-                        print_error(format!("Malformed pattern in global ignore file. {}.", err));
-                    }
-                    None => (),
-                }
-            }
+impl Batch {
+    fn new() -> Self {
+        Self {
+            items: Arc::new(Mutex::new(Some(vec![]))),
        }
    }

-    for ignore_file in &config.ignore_files {
-        let result = walker.add_ignore(ignore_file);
-        match result {
-            Some(ignore::Error::Partial(_)) => (),
-            Some(err) => {
-                print_error(format!("Malformed pattern in custom ignore file. {}.", err));
-            }
-            None => (),
-        }
-    }
-
-    for path in &paths[1..] {
-        walker.add(path);
-    }
-
-    let parallel_walker = walker.threads(config.threads).build_parallel();
-
-    // Flag for cleanly shutting down the parallel walk
-    let quit_flag = Arc::new(AtomicBool::new(false));
-    // Flag specifically for quitting due to ^C
-    let interrupt_flag = Arc::new(AtomicBool::new(false));
-
-    if config.ls_colors.is_some() && config.is_printing() {
-        let quit_flag = Arc::clone(&quit_flag);
-        let interrupt_flag = Arc::clone(&interrupt_flag);
-
-        ctrlc::set_handler(move || {
-            quit_flag.store(true, Ordering::Relaxed);
-
-            if interrupt_flag.fetch_or(true, Ordering::Relaxed) {
-                // Ctrl-C has been pressed twice, exit NOW
-                ExitCode::KilledBySigint.exit();
-            }
-        })
-        .unwrap();
-    }
-
-    // Spawn the thread that receives all results through the channel.
-    let receiver_thread = spawn_receiver(&config, &quit_flag, &interrupt_flag, rx);
-
-    // Spawn the sender threads.
-    spawn_senders(&config, &quit_flag, patterns, parallel_walker, tx);
-
-    // Wait for the receiver thread to print out all results.
-    let exit_code = receiver_thread.join().unwrap();
-
-    if interrupt_flag.load(Ordering::Relaxed) {
-        Ok(ExitCode::KilledBySigint)
-    } else {
-        Ok(exit_code)
+    fn lock(&self) -> MutexGuard<'_, Option<Vec<WorkerResult>>> {
+        self.items.lock().unwrap()
    }
 }

+impl IntoIterator for Batch {
+    type Item = WorkerResult;
+    type IntoIter = std::vec::IntoIter<WorkerResult>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.lock().take().unwrap().into_iter()
+    }
+}
+
+/// Wrapper that sends batches of items at once over a channel.
+struct BatchSender {
+    batch: Batch,
+    tx: Sender<Batch>,
+    limit: usize,
+}
+
+impl BatchSender {
+    fn new(tx: Sender<Batch>, limit: usize) -> Self {
+        Self {
+            batch: Batch::new(),
+            tx,
+            limit,
+        }
+    }
+
+    /// Check if we need to flush a batch.
+    fn needs_flush(&self, batch: Option<&Vec<WorkerResult>>) -> bool {
+        match batch {
+            // Limit the batch size to provide some backpressure
+            Some(vec) => vec.len() >= self.limit,
+            // Batch was already taken by the receiver, so make a new one
+            None => true,
+        }
+    }
+
+    /// Add an item to a batch.
+    fn send(&mut self, item: WorkerResult) -> Result<(), SendError<()>> {
+        let mut batch = self.batch.lock();
+
+        if self.needs_flush(batch.as_ref()) {
+            drop(batch);
+            self.batch = Batch::new();
+            batch = self.batch.lock();
+        }
+
+        let items = batch.as_mut().unwrap();
+        items.push(item);
+
+        if items.len() == 1 {
+            // New batch, send it over the channel
+            self.tx
+                .send(self.batch.clone())
+                .map_err(|_| SendError(()))?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Maximum size of the output buffer before flushing results to the console
+const MAX_BUFFER_LENGTH: usize = 1000;
+/// Default duration until output buffering switches to streaming.
+const DEFAULT_MAX_BUFFER_TIME: Duration = Duration::from_millis(100);
+
 /// Wrapper for the receiver thread's buffering behavior.
-struct ReceiverBuffer<W> {
+struct ReceiverBuffer<'a, W> {
    /// The configuration.
-    config: Arc<Config>,
+    config: &'a Config,
    /// For shutting down the senders.
-    quit_flag: Arc<AtomicBool>,
+    quit_flag: &'a AtomicBool,
    /// The ^C notifier.
-    interrupt_flag: Arc<AtomicBool>,
+    interrupt_flag: &'a AtomicBool,
    /// Receiver for worker results.
-    rx: Receiver<WorkerResult>,
+    rx: Receiver<Batch>,
    /// Standard output.
    stdout: W,
    /// The current buffer mode.
@@ -180,15 +148,12 @@ struct ReceiverBuffer<W> {
    num_results: usize,
 }

-impl<W: Write> ReceiverBuffer<W> {
+impl<'a, W: Write> ReceiverBuffer<'a, W> {
    /// Create a new receiver buffer.
-    fn new(
-        config: Arc<Config>,
-        quit_flag: Arc<AtomicBool>,
-        interrupt_flag: Arc<AtomicBool>,
-        rx: Receiver<WorkerResult>,
-        stdout: W,
-    ) -> Self {
+    fn new(state: &'a WorkerState, rx: Receiver<Batch>, stdout: W) -> Self {
+        let config = &state.config;
+        let quit_flag = state.quit_flag.as_ref();
+        let interrupt_flag = state.interrupt_flag.as_ref();
        let max_buffer_time = config.max_buffer_time.unwrap_or(DEFAULT_MAX_BUFFER_TIME);
        let deadline = Instant::now() + max_buffer_time;

@@ -216,7 +181,7 @@ impl<W: Write> ReceiverBuffer<W> {
    }

    /// Receive the next worker result.
-    fn recv(&self) -> Result<WorkerResult, RecvTimeoutError> {
+    fn recv(&self) -> Result<Batch, RecvTimeoutError> {
        match self.mode {
            ReceiverMode::Buffering => {
                // Wait at most until we should switch to streaming
@@ -232,34 +197,44 @@ impl<W: Write> ReceiverBuffer<W> {
    /// Wait for a result or state change.
    fn poll(&mut self) -> Result<(), ExitCode> {
        match self.recv() {
-            Ok(WorkerResult::Entry(dir_entry)) => {
-                if self.config.quiet {
-                    return Err(ExitCode::HasResults(true));
-                }
+            Ok(batch) => {
+                for result in batch {
+                    match result {
+                        WorkerResult::Entry(dir_entry) => {
+                            if self.config.quiet {
+                                return Err(ExitCode::HasResults(true));
+                            }

-                match self.mode {
-                    ReceiverMode::Buffering => {
-                        self.buffer.push(dir_entry);
-                        if self.buffer.len() > MAX_BUFFER_LENGTH {
-                            self.stream()?;
+                            match self.mode {
+                                ReceiverMode::Buffering => {
+                                    self.buffer.push(dir_entry);
+                                    if self.buffer.len() > MAX_BUFFER_LENGTH {
+                                        self.stream()?;
+                                    }
+                                }
+                                ReceiverMode::Streaming => {
+                                    self.print(&dir_entry)?;
+                                }
+                            }
+
+                            self.num_results += 1;
+                            if let Some(max_results) = self.config.max_results
+                                && self.num_results >= max_results
+                            {
+                                return self.stop();
+                            }
+                        }
+                        WorkerResult::Error(err) => {
+                            if self.config.show_filesystem_errors {
+                                print_error(err.to_string());
+                            }
                        }
                    }
-                    ReceiverMode::Streaming => {
-                        self.print(&dir_entry)?;
-                        self.flush()?;
-                    }
                }

-                self.num_results += 1;
-                if let Some(max_results) = self.config.max_results {
-                    if self.num_results >= max_results {
-                        return self.stop();
-                    }
-                }
-            }
-            Ok(WorkerResult::Error(err)) => {
-                if self.config.show_filesystem_errors {
-                    print_error(err.to_string());
+                // If we don't have another batch ready, flush before waiting
+                if self.mode == ReceiverMode::Streaming && self.rx.is_empty() {
+                    self.flush()?;
                }
            }
            Err(RecvTimeoutError::Timeout) => {
@@ -275,7 +250,12 @@ impl<W: Write> ReceiverBuffer<W> {

    /// Output a path.
    fn print(&mut self, entry: &DirEntry) -> Result<(), ExitCode> {
-        output::print_entry(&mut self.stdout, entry, &self.config);
+        if let Err(e) = output::print_entry(&mut self.stdout, entry, self.config)
+            && e.kind() != ::std::io::ErrorKind::BrokenPipe
+        {
+            print_error(format!("Could not write to output: {e}"));
+            return Err(ExitCode::GeneralError);
+        }

        if self.interrupt_flag.load(Ordering::Relaxed) {
            // Ignore any errors on flush, because we're about to exit anyway
@@ -314,7 +294,7 @@ impl<W: Write> ReceiverBuffer<W> {

    /// Flush stdout if necessary.
    fn flush(&mut self) -> Result<(), ExitCode> {
-        if self.config.interactive_terminal && self.stdout.flush().is_err() {
+        if self.stdout.flush().is_err() {
            // Probably a broken pipe. Exit gracefully.
            return Err(ExitCode::GeneralError);
        }
@@ -322,33 +302,127 @@ impl<W: Write> ReceiverBuffer<W> {
    }
 }

-fn spawn_receiver(
-    config: &Arc<Config>,
-    quit_flag: &Arc<AtomicBool>,
-    interrupt_flag: &Arc<AtomicBool>,
-    rx: Receiver<WorkerResult>,
-) -> thread::JoinHandle<ExitCode> {
-    let config = Arc::clone(config);
-    let quit_flag = Arc::clone(quit_flag);
-    let interrupt_flag = Arc::clone(interrupt_flag);
+/// State shared by the sender and receiver threads.
+struct WorkerState {
+    /// The search patterns.
+    patterns: Vec<Regex>,
+    /// The command line configuration.
+    config: Config,
+    /// Flag for cleanly shutting down the parallel walk
+    quit_flag: Arc<AtomicBool>,
+    /// Flag specifically for quitting due to ^C
+    interrupt_flag: Arc<AtomicBool>,
+}
+
+impl WorkerState {
+    fn new(patterns: Vec<Regex>, config: Config) -> Self {
+        let quit_flag = Arc::new(AtomicBool::new(false));
+        let interrupt_flag = Arc::new(AtomicBool::new(false));
+
+        Self {
+            patterns,
+            config,
+            quit_flag,
+            interrupt_flag,
+        }
+    }
+
+    fn build_overrides(&self, paths: &[PathBuf]) -> Result<Override> {
+        let first_path = &paths[0];
+        let config = &self.config;
+
+        let mut builder = OverrideBuilder::new(first_path);
+
+        for pattern in &config.exclude_patterns {
+            builder
+                .add(pattern)
+                .map_err(|e| anyhow!("Malformed exclude pattern: {}", e))?;
+        }
+
+        builder
+            .build()
+            .map_err(|_| anyhow!("Mismatch in exclude patterns"))
+    }
+
+    fn build_walker(&self, paths: &[PathBuf]) -> Result<WalkParallel> {
+        let first_path = &paths[0];
+        let config = &self.config;
+        let overrides = self.build_overrides(paths)?;
+
+        let mut builder = WalkBuilder::new(first_path);
+        builder
+            .hidden(config.ignore_hidden)
+            .ignore(config.read_fdignore)
+            .parents(config.read_parent_ignore && (config.read_fdignore || config.read_vcsignore))
+            .git_ignore(config.read_vcsignore)
+            .git_global(config.read_vcsignore)
+            .git_exclude(config.read_vcsignore)
+            .require_git(config.require_git_to_read_vcsignore)
+            .overrides(overrides)
+            .follow_links(config.follow_links)
+            // No need to check for supported platforms, option is unavailable on unsupported ones
+            .same_file_system(config.one_file_system)
+            .max_depth(config.max_depth);
+
+        if config.read_fdignore {
+            builder.add_custom_ignore_filename(".fdignore");
+        }
+
+        if config.read_global_ignore
+            && let Ok(basedirs) = etcetera::choose_base_strategy()
+        {
+            let global_ignore_file = basedirs.config_dir().join("fd").join("ignore");
+            if global_ignore_file.is_file() {
+                let result = builder.add_ignore(global_ignore_file);
+                match result {
+                    Some(ignore::Error::Partial(_)) => (),
+                    Some(err) => {
+                        print_error(format!("Malformed pattern in global ignore file. {err}."));
+                    }
+                    None => (),
+                }
+            }
+        }
+
+        for ignore_file in &config.ignore_files {
+            let result = builder.add_ignore(ignore_file);
+            match result {
+                Some(ignore::Error::Partial(_)) => (),
+                Some(err) => {
+                    print_error(format!("Malformed pattern in custom ignore file. {err}."));
+                }
+                None => (),
+            }
+        }
+
+        for path in &paths[1..] {
+            builder.add(path);
+        }
+
+        let walker = builder.threads(config.threads).build_parallel();
+        Ok(walker)
+    }
+
+    /// Run the receiver work, either on this thread or a pool of background
+    /// threads (for --exec).
+    fn receive(&self, rx: Receiver<Batch>) -> ExitCode {
+        let config = &self.config;

-    let threads = config.threads;
-    thread::spawn(move || {
        // This will be set to `Some` if the `--exec` argument was supplied.
        if let Some(ref cmd) = config.command {
            if cmd.in_batch_mode() {
-                exec::batch(rx, cmd, &config)
+                exec::batch(rx.into_iter().flatten(), cmd, config)
            } else {
-                let out_perm = Mutex::new(());
-
                thread::scope(|scope| {
-                    // Each spawned job will store it's thread handle in here.
+                    // Each spawned job will store its thread handle in here.
+                    let threads = config.threads;
                    let mut handles = Vec::with_capacity(threads);
                    for _ in 0..threads {
                        let rx = rx.clone();

                        // Spawn a job thread that will listen for and execute inputs.
-                        let handle = scope.spawn(|| exec::job(rx, cmd, &out_perm, &config));
+                        let handle =
+                            scope.spawn(|| exec::job(rx.into_iter().flatten(), cmd, config));

                        // Push the handle of the spawned thread into the vector for later joining.
                        handles.push(handle);
@@ -358,188 +432,313 @@ fn spawn_receiver(
                })
            }
        } else {
-            let stdout = io::stdout();
-            let stdout = stdout.lock();
+            let stdout = io::stdout().lock();
            let stdout = io::BufWriter::new(stdout);

-            let mut rxbuffer = ReceiverBuffer::new(config, quit_flag, interrupt_flag, rx, stdout);
-            rxbuffer.process()
+            ReceiverBuffer::new(self, rx, stdout).process()
        }
-    })
-}
+    }

-fn spawn_senders(
-    config: &Arc<Config>,
-    quit_flag: &Arc<AtomicBool>,
-    patterns: Arc<Vec<Regex>>,
-    parallel_walker: ignore::WalkParallel,
-    tx: Sender<WorkerResult>,
-) {
-    parallel_walker.run(|| {
-        let config = Arc::clone(config);
-        let patterns = Arc::clone(&patterns);
-        let tx_thread = tx.clone();
-        let quit_flag = Arc::clone(quit_flag);
+    /// Spawn the sender threads.
+    fn spawn_senders(&self, walker: WalkParallel, tx: Sender<Batch>) {
+        walker.run(|| {
+            let patterns = &self.patterns;
+            let config = &self.config;
+            let quit_flag = self.quit_flag.as_ref();

-        Box::new(move |entry_o| {
-            if quit_flag.load(Ordering::Relaxed) {
-                return ignore::WalkState::Quit;
+            let mut limit = 0x100;
+            if let Some(cmd) = &config.command
+                && !cmd.in_batch_mode()
+                && config.threads > 1
+            {
+                // Evenly distribute work between multiple receivers
+                limit = 1;
            }
+            let mut tx = BatchSender::new(tx.clone(), limit);

-            let entry = match entry_o {
-                Ok(ref e) if e.depth() == 0 => {
-                    // Skip the root directory entry.
-                    return ignore::WalkState::Continue;
+            Box::new(move |entry| {
+                if quit_flag.load(Ordering::Relaxed) {
+                    return WalkState::Quit;
                }
-                Ok(e) => DirEntry::normal(e),
-                Err(ignore::Error::WithPath {
-                    path,
-                    err: inner_err,
-                }) => match inner_err.as_ref() {
-                    ignore::Error::Io(io_error)
-                        if io_error.kind() == io::ErrorKind::NotFound
-                            && path
-                                .symlink_metadata()
-                                .ok()
-                                .map_or(false, |m| m.file_type().is_symlink()) =>
+
+                if let Ok(e) = &entry {
+                    // If the entry is a directory that contains a
+                    // "ignore contain" file", we want to skip this
+                    // directory.
+                    // Check the filetype first to avoid unnecessary
+                    // syscalls.
+                    if e.file_type().is_some_and(|t| t.is_dir()) {
+                        let entry_path = e.path();
+                        if config
+                            .ignore_contain
+                            .iter()
+                            .any(|ic| entry_path.join(ic).exists())
+                        {
+                            return WalkState::Skip;
+                        }
+                    }
+                    if e.depth() == 0 {
+                        // Skip the root directory entry.
+                        return WalkState::Continue;
+                    }
+                }
+                let entry = match entry {
+                    Ok(e) => DirEntry::normal(e),
+                    Err(ignore::Error::WithPath {
+                        path,
+                        err: inner_err,
+                    }) if inner_err
+                        .io_error()
+                        .is_some_and(|io_error| io_error.kind() == io::ErrorKind::NotFound)
+                        && path
+                            .symlink_metadata()
+                            .ok()
+                            .is_some_and(|m| m.file_type().is_symlink()) =>
                    {
                        DirEntry::broken_symlink(path)
                    }
-                    _ => {
-                        return match tx_thread.send(WorkerResult::Error(ignore::Error::WithPath {
-                            path,
-                            err: inner_err,
-                        })) {
-                            Ok(_) => ignore::WalkState::Continue,
-                            Err(_) => ignore::WalkState::Quit,
-                        }
-                    }
-                },
-                Err(err) => {
-                    return match tx_thread.send(WorkerResult::Error(err)) {
-                        Ok(_) => ignore::WalkState::Continue,
-                        Err(_) => ignore::WalkState::Quit,
+                    Err(err) => {
+                        return match tx.send(WorkerResult::Error(err)) {
+                            Ok(_) => WalkState::Continue,
+                            Err(_) => WalkState::Quit,
+                        };
                    }
+                };
+
+                if let Some(min_depth) = config.min_depth
+                    && entry.depth().is_none_or(|d| d < min_depth)
+                {
+                    return WalkState::Continue;
                }
-            };

-            if let Some(min_depth) = config.min_depth {
-                if entry.depth().map_or(true, |d| d < min_depth) {
-                    return ignore::WalkState::Continue;
+                // Check the name first, since it doesn't require metadata
+                let entry_path = entry.path();
+
+                let search_str = search_str_for_entry(entry_path, config.full_path_base.as_deref());
+
+                if !patterns
+                    .iter()
+                    .all(|pat| pat.is_match(&filesystem::osstr_to_bytes(search_str.as_ref())))
+                {
+                    return WalkState::Continue;
                }
-            }

-            // Check the name first, since it doesn't require metadata
-            let entry_path = entry.path();
-
-            let search_str: Cow<OsStr> = if config.search_full_path {
-                let path_abs_buf = filesystem::path_absolute_form(entry_path)
-                    .expect("Retrieving absolute path succeeds");
-                Cow::Owned(path_abs_buf.as_os_str().to_os_string())
-            } else {
-                match entry_path.file_name() {
-                    Some(filename) => Cow::Borrowed(filename),
-                    None => unreachable!(
-                        "Encountered file system entry without a file name. This should only \
-                         happen for paths like 'foo/bar/..' or '/' which are not supposed to \
-                         appear in a file system traversal."
-                    ),
-                }
-            };
-
-            if !patterns
-                .iter()
-                .all(|pat| pat.is_match(&filesystem::osstr_to_bytes(search_str.as_ref())))
-            {
-                return ignore::WalkState::Continue;
-            }
-
-            // Filter out unwanted extensions.
-            if let Some(ref exts_regex) = config.extensions {
-                if let Some(path_str) = entry_path.file_name() {
-                    if !exts_regex.is_match(&filesystem::osstr_to_bytes(path_str)) {
-                        return ignore::WalkState::Continue;
-                    }
-                } else {
-                    return ignore::WalkState::Continue;
-                }
-            }
-
-            // Filter out unwanted file types.
-            if let Some(ref file_types) = config.file_types {
-                if file_types.should_ignore(&entry) {
-                    return ignore::WalkState::Continue;
-                }
-            }
-
-            #[cfg(unix)]
-            {
-                if let Some(ref owner_constraint) = config.owner_constraint {
-                    if let Some(metadata) = entry.metadata() {
-                        if !owner_constraint.matches(metadata) {
-                            return ignore::WalkState::Continue;
+                // Filter out unwanted extensions.
+                if let Some(ref exts_regex) = config.extensions {
+                    if let Some(path_str) = entry_path.file_name() {
+                        if !exts_regex.is_match(&filesystem::osstr_to_bytes(path_str)) {
+                            return WalkState::Continue;
                        }
                    } else {
-                        return ignore::WalkState::Continue;
+                        return WalkState::Continue;
                    }
                }
-            }

-            // Filter out unwanted sizes if it is a file and we have been given size constraints.
-            if !config.size_constraints.is_empty() {
-                if entry_path.is_file() {
-                    if let Some(metadata) = entry.metadata() {
-                        let file_size = metadata.len();
-                        if config
-                            .size_constraints
-                            .iter()
-                            .any(|sc| !sc.is_within(file_size))
-                        {
-                            return ignore::WalkState::Continue;
+                // Filter out unwanted file types.
+                if let Some(ref file_types) = config.file_types
+                    && file_types.should_ignore(&entry)
+                {
+                    return WalkState::Continue;
+                }
+
+                #[cfg(unix)]
+                {
+                    if let Some(ref owner_constraint) = config.owner_constraint {
+                        if let Some(metadata) = entry.metadata() {
+                            if !owner_constraint.matches(metadata) {
+                                return WalkState::Continue;
+                            }
+                        } else {
+                            return WalkState::Continue;
+                        }
+                    }
+                }
+
+                // Filter out unwanted sizes if it is a file and we have been given size constraints.
+                if !config.size_constraints.is_empty() {
+                    if entry_path.is_file() {
+                        if let Some(metadata) = entry.metadata() {
+                            let file_size = metadata.len();
+                            if config
+                                .size_constraints
+                                .iter()
+                                .any(|sc| !sc.is_within(file_size))
+                            {
+                                return WalkState::Continue;
+                            }
+                        } else {
+                            return WalkState::Continue;
                        }
                    } else {
-                        return ignore::WalkState::Continue;
+                        return WalkState::Continue;
                    }
-                } else {
-                    return ignore::WalkState::Continue;
                }
-            }

-            // Filter out unwanted modification times
-            if !config.time_constraints.is_empty() {
-                let mut matched = false;
-                if let Some(metadata) = entry.metadata() {
-                    if let Ok(modified) = metadata.modified() {
+                // Filter out unwanted modification times
+                if !config.time_constraints.is_empty() {
+                    let mut matched = false;
+                    if let Some(metadata) = entry.metadata()
+                        && let Ok(modified) = metadata.modified()
+                    {
                        matched = config
                            .time_constraints
                            .iter()
                            .all(|tf| tf.applies_to(&modified));
                    }
+                    if !matched {
+                        return WalkState::Continue;
+                    }
                }
-                if !matched {
-                    return ignore::WalkState::Continue;
-                }
-            }

-            if config.is_printing() {
-                if let Some(ls_colors) = &config.ls_colors {
+                if config.is_printing()
+                    && let Some(ls_colors) = &config.ls_colors
+                {
                    // Compute colors in parallel
                    entry.style(ls_colors);
                }
-            }

-            let send_result = tx_thread.send(WorkerResult::Entry(entry));
+                let send_result = tx.send(WorkerResult::Entry(entry));

-            if send_result.is_err() {
-                return ignore::WalkState::Quit;
-            }
+                if send_result.is_err() {
+                    return WalkState::Quit;
+                }

-            // Apply pruning.
-            if config.prune {
-                return ignore::WalkState::Skip;
-            }
+                // Apply pruning.
+                if config.prune {
+                    return WalkState::Skip;
+                }

-            ignore::WalkState::Continue
-        })
-    });
+                WalkState::Continue
+            })
+        });
+    }
+
+    /// Perform the recursive scan.
+    fn scan(&self, paths: &[PathBuf]) -> Result<ExitCode> {
+        let config = &self.config;
+        let walker = self.build_walker(paths)?;
+
+        if config.ls_colors.is_some() && config.is_printing() {
+            let quit_flag = Arc::clone(&self.quit_flag);
+            let interrupt_flag = Arc::clone(&self.interrupt_flag);
+
+            ctrlc::set_handler(move || {
+                quit_flag.store(true, Ordering::Relaxed);
+
+                if interrupt_flag.fetch_or(true, Ordering::Relaxed) {
+                    // Ctrl-C has been pressed twice, exit NOW
+                    ExitCode::KilledBySigint.exit();
+                }
+            })
+            .unwrap();
+        }
+
+        let (tx, rx) = bounded(2 * config.threads);
+
+        let exit_code = thread::scope(|scope| {
+            // Spawn the receiver thread(s)
+            let receiver = scope.spawn(|| self.receive(rx));
+
+            // Spawn the sender threads.
+            self.spawn_senders(walker, tx);
+
+            receiver.join().unwrap()
+        });
+
+        if self.interrupt_flag.load(Ordering::Relaxed) {
+            Ok(ExitCode::KilledBySigint)
+        } else {
+            Ok(exit_code)
+        }
+    }
+}
+
+fn search_str_for_entry<'a>(
+    entry_path: &'a std::path::Path,
+    full_path_base: Option<&std::path::Path>,
+) -> Cow<'a, OsStr> {
+    if let Some(cwd) = full_path_base {
+        // If full_path_base is some, that means that we need to return
+        // the absolute path
+        if entry_path.is_absolute() {
+            return Cow::Borrowed(entry_path.as_os_str());
+        }
+        let path = entry_path.strip_prefix(".").unwrap_or(entry_path);
+        Cow::Owned(cwd.join(path).into())
+    } else {
+        match entry_path.file_name() {
+            Some(filename) => Cow::Borrowed(filename),
+            None => unreachable!(
+                "Encountered file system entry without a file name. This should only \
+                 happen for paths like 'foo/bar/..' or '/' which are not supposed to \
+                 appear in a file system traversal."
+            ),
+        }
+    }
+}
+
+/// Recursively scan the given search path for files / pathnames matching the patterns.
+///
+/// If the `--exec` argument was supplied, this will create a thread pool for executing
+/// jobs in parallel from a given command line and the discovered paths. Otherwise, each
+/// path will simply be written to standard output.
+pub fn scan(paths: &[PathBuf], patterns: Vec<Regex>, config: Config) -> Result<ExitCode> {
+    WorkerState::new(patterns, config).scan(paths)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::search_str_for_entry;
+    use std::path::{Path, PathBuf};
+
+    #[test]
+    fn search_str_for_entry_with_relative_path() {
+        let full_path_base = Some(Path::new("/home/user"));
+        assert_eq!(
+            search_str_for_entry(Path::new("foo/bar"), full_path_base),
+            PathBuf::from("/home/user/foo/bar")
+        );
+    }
+
+    #[test]
+    fn search_str_for_entry_strips_dot_prefix() {
+        let full_path_base = Some(Path::new("/home/user"));
+        assert_eq!(
+            search_str_for_entry(Path::new("./foo/bar"), full_path_base),
+            PathBuf::from("/home/user/foo/bar")
+        );
+    }
+
+    #[test]
+    fn search_str_for_entry_with_absolute_path() {
+        let full_path_base = Some(Path::new("/home/user"));
+        assert_eq!(
+            search_str_for_entry(Path::new("/absolute/path"), full_path_base),
+            PathBuf::from("/absolute/path")
+        );
+    }
+
+    #[test]
+    fn search_str_no_base_dir() {
+        assert_eq!(
+            search_str_for_entry(Path::new("./foo/bar"), None),
+            PathBuf::from("bar")
+        );
+    }
+
+    #[test]
+    fn search_str_no_base_dir_with_plain_relative_path() {
+        assert_eq!(
+            search_str_for_entry(Path::new("foo/bar"), None),
+            PathBuf::from("bar")
+        );
+    }
+
+    #[test]
+    fn search_str_no_base_dir_with_file_in_current_dir() {
+        assert_eq!(
+            search_str_for_entry(Path::new("foo"), None),
+            PathBuf::from("foo")
+        );
+    }
 }
@@ -74,18 +74,8 @@ fn create_config_directory_with_global_ignore(ignore_file_content: &str) -> io::

 /// Find the *fd* executable.
 fn find_fd_exe() -> PathBuf {
-    // Tests exe is in target/debug/deps, the *fd* exe is in target/debug
-    let root = env::current_exe()
-        .expect("tests executable")
-        .parent()
-        .expect("tests executable directory")
-        .parent()
-        .expect("fd executable directory")
-        .to_path_buf();
-
-    let exe_name = if cfg!(windows) { "fd.exe" } else { "fd" };
-
-    root.join(exe_name)
+    // Read the location of the fd executable from the environment
+    PathBuf::from(env::var("CARGO_BIN_EXE_fd").unwrap_or(env!("CARGO_BIN_EXE_fd").to_string()))
 }

 /// Format an error message for when *fd* did not exit successfully.
@@ -104,9 +94,9 @@ fn format_output_error(args: &[&str], expected: &str, actual: &str) -> String {
    let diff_text = diff::lines(expected, actual)
        .into_iter()
        .map(|diff| match diff {
-            diff::Result::Left(l) => format!("-{}", l),
-            diff::Result::Both(l, _) => format!(" {}", l),
-            diff::Result::Right(r) => format!("+{}", r),
+            diff::Result::Left(l) => format!("-{l}"),
+            diff::Result::Both(l, _) => format!(" {l}"),
+            diff::Result::Right(r) => format!("+{r}"),
        })
        .collect::<Vec<_>>()
        .join("\n");
@@ -129,7 +119,7 @@ fn normalize_output(s: &str, trim_start: bool, normalize_line: bool) -> String {
        .lines()
        .map(|line| {
            let line = if trim_start { line.trim_start() } else { line };
-            let line = line.replace('/', &std::path::MAIN_SEPARATOR.to_string());
+            let line = line.replace('/', std::path::MAIN_SEPARATOR_STR);
            if normalize_line {
                let mut words: Vec<_> = line.split_whitespace().collect();
                words.sort_unstable();
@@ -290,7 +280,7 @@ impl TestEnv {
    pub fn assert_failure_with_error(&self, args: &[&str], expected: &str) {
        let status = self.assert_error_subdirectory(".", args, Some(expected));
        if status.success() {
-            panic!("error '{}' did not occur.", expected);
+            panic!("error '{expected}' did not occur.");
        }
    }

@@ -316,6 +306,9 @@ impl TestEnv {
        } else {
            cmd.arg("--no-global-ignore-file");
        }
+        // Make sure LS_COLORS is unset to ensure consistent
+        // color output
+        cmd.env("LS_COLORS", "");
        cmd.args(args);

        // Run *fd*.
@@ -1,11 +1,14 @@
 mod testenv;

+#[cfg(unix)]
+use nix::unistd::{Gid, Group, Uid, User};
 use std::fs;
 use std::io::Write;
 use std::path::Path;
 use std::time::{Duration, SystemTime};
 use test_case::test_case;

+use jiff::Timestamp;
 use normpath::PathExt;
 use regex::escape;

@@ -371,6 +374,74 @@ fn test_multi_file_with_missing() {
    );
 }

+/// Without --full-path, a pattern containing '/' should always produce the
+/// path-separator diagnostic, even if the pattern does not name an existing
+/// directory. Before the fix for sharkdp/fd#1873 this only fired when the
+/// pattern happened to resolve to a real directory, so the common typo of
+/// pasting a full path silently returned zero matches.
+#[test]
+fn test_pattern_with_forward_slash_is_rejected() {
+    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
+
+    // Pattern that is NOT a real directory; old behaviour: no warning.
+    te.assert_failure_with_error(
+        &["nonexistent/path"],
+        "[fd error]: The search pattern 'nonexistent/path' contains a path-separation character and will not lead to any search results.",
+    );
+
+    // Pattern that IS a real directory; old behaviour: warning. Must still fire.
+    te.assert_failure_with_error(
+        &["one/two/three"],
+        "[fd error]: The search pattern 'one/two/three' contains a path-separation character and will not lead to any search results.",
+    );
+}
+
+/// --full-path is the user's explicit opt-in to regex-over-full-path matching,
+/// so a path-separation character in the pattern is expected and must not
+/// trigger the diagnostic.
+///
+/// Gated off Windows: the actual match is regex-over-the-full-path, so a
+/// forward-slash pattern only matches Unix-style paths. On Windows the OS
+/// uses `\` and `one/two/c` (as a literal regex) does not match a real
+/// entry — the behaviour this test is pinning (the diagnostic does not
+/// fire) is covered by the fact that the invocation does not error.
+#[test]
+#[cfg(not(windows))]
+fn test_pattern_with_forward_slash_allowed_with_full_path() {
+    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
+
+    te.assert_output(
+        &["--full-path", "one/two/c"],
+        "one/two/c.foo
+        one/two/C.Foo2",
+    );
+}
+
+/// `--and` patterns are matched against the file name exactly like the primary
+/// pattern, so a path separator in any of them is the same silent "no results"
+/// footgun and must trigger the same diagnostic. Regression for the sibling of
+/// #1873 left unchecked by #1975 (only the positional pattern was validated).
+#[test]
+fn test_and_pattern_with_forward_slash_is_rejected() {
+    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
+
+    // Clean primary pattern, but a `--and` pattern carrying a path separator.
+    te.assert_failure_with_error(
+        &["foo", "--and", "nonexistent/path"],
+        "[fd error]: The search pattern 'nonexistent/path' contains a path-separation character and will not lead to any search results.",
+    );
+
+    // `--full-path` is the explicit opt-in and must still suppress the
+    // diagnostic for `--and` patterns too (the invocation runs and matches
+    // instead of erroring on the path separator).
+    #[cfg(not(windows))]
+    te.assert_output(
+        &["--full-path", "one/two/c", "--and", "two/c"],
+        "one/two/c.foo
+        one/two/C.Foo2",
+    );
+}
+
 /// Explicit root path
 #[test]
 fn test_explicit_root_path() {
@@ -413,6 +484,13 @@ fn test_explicit_root_path() {
    );
 }

+#[test]
+fn test_single_dash_root_path() {
+    let te = TestEnv::new(&["-"], &["-/foo"]);
+
+    te.assert_output(&[".", "-"], "./-/foo");
+}
+
 /// Regex searches
 #[test]
 fn test_regex_searches() {
@@ -593,10 +671,7 @@ fn test_full_path() {
    let prefix = escape(&root.to_string_lossy());

    te.assert_output(
-        &[
-            "--full-path",
-            &format!("^{prefix}.*three.*foo$", prefix = prefix),
-        ],
+        &["--full-path", &format!("^{prefix}.*three.*foo$")],
        "one/two/three/d.foo
        one/two/three/directory_foo/",
    );
@@ -1199,7 +1274,7 @@ fn test_absolute_path() {
            {abs_path}/one/two/three/d.foo
            {abs_path}/one/two/three/directory_foo/
            {abs_path}/symlink",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );

@@ -1212,7 +1287,7 @@ fn test_absolute_path() {
            {abs_path}/one/two/C.Foo2
            {abs_path}/one/two/three/d.foo
            {abs_path}/one/two/three/directory_foo/",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );
 }
@@ -1231,7 +1306,7 @@ fn test_implicit_absolute_path() {
            {abs_path}/one/two/C.Foo2
            {abs_path}/one/two/three/d.foo
            {abs_path}/one/two/three/directory_foo/",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );
 }
@@ -1251,7 +1326,7 @@ fn test_normalized_absolute_path() {
            {abs_path}/one/two/C.Foo2
            {abs_path}/one/two/three/d.foo
            {abs_path}/one/two/three/directory_foo/",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );
 }
@@ -1302,14 +1377,15 @@ fn test_type_executable() {
    // This test assumes the current user isn't root
    // (otherwise if the executable bit is set for any level, it is executable for the current
    // user)
-    if users::get_current_uid() == 0 {
+    if Uid::current().is_root() {
        return;
    }

    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);

    fs::OpenOptions::new()
-        .create(true)
+        .create_new(true)
+        .truncate(true)
        .write(true)
        .mode(0o777)
        .open(te.test_root().join("executable-file.sh"))
@@ -1317,6 +1393,7 @@ fn test_type_executable() {

    fs::OpenOptions::new()
        .create(true)
+        .truncate(true)
        .write(true)
        .mode(0o645)
        .open(te.test_root().join("not-user-executable-file.sh"))
@@ -1483,7 +1560,7 @@ fn test_symlink_as_root() {
            {dir}/one/two/three/d.foo
            {dir}/one/two/three/directory_foo/
            {dir}/symlink",
-            dir = &parent_parent
+            dir = parent_parent
        ),
    );
 }
@@ -1503,7 +1580,7 @@ fn test_symlink_and_absolute_path() {
            {abs_path}/{expected_path}/three/
            {abs_path}/{expected_path}/three/d.foo
            {abs_path}/{expected_path}/three/directory_foo/",
-            abs_path = &abs_path,
+            abs_path = abs_path,
            expected_path = expected_path
        ),
    );
@@ -1514,14 +1591,14 @@ fn test_symlink_as_absolute_root() {
    let (te, abs_path) = get_test_env_with_abs_path(DEFAULT_DIRS, DEFAULT_FILES);

    te.assert_output(
-        &["", &format!("{abs_path}/symlink", abs_path = abs_path)],
+        &["", &format!("{abs_path}/symlink")],
        &format!(
            "{abs_path}/symlink/c.foo
            {abs_path}/symlink/C.Foo2
            {abs_path}/symlink/three/
            {abs_path}/symlink/three/d.foo
            {abs_path}/symlink/three/directory_foo/",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );
 }
@@ -1539,13 +1616,13 @@ fn test_symlink_and_full_path() {
        &[
            "--absolute-path",
            "--full-path",
-            &format!("^{prefix}.*three", prefix = prefix),
+            &format!("^{prefix}.*three"),
        ],
        &format!(
            "{abs_path}/{expected_path}/three/
            {abs_path}/{expected_path}/three/d.foo
            {abs_path}/{expected_path}/three/directory_foo/",
-            abs_path = &abs_path,
+            abs_path = abs_path,
            expected_path = expected_path
        ),
    );
@@ -1559,14 +1636,14 @@ fn test_symlink_and_full_path_abs_path() {
    te.assert_output(
        &[
            "--full-path",
-            &format!("^{prefix}.*symlink.*three", prefix = prefix),
-            &format!("{abs_path}/symlink", abs_path = abs_path),
+            &format!("^{prefix}.*symlink.*three"),
+            &format!("{abs_path}/symlink"),
        ],
        &format!(
            "{abs_path}/symlink/three/
            {abs_path}/symlink/three/d.foo
            {abs_path}/symlink/three/directory_foo/",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );
 }
@@ -1620,6 +1697,66 @@ fn test_excludes() {
    );
 }

+#[test]
+fn format() {
+    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
+
+    te.assert_output(
+        &["--format", "path={}", "--path-separator=/"],
+        "path=a.foo
+        path=e1 e2
+        path=one
+        path=one/b.foo
+        path=one/two
+        path=one/two/C.Foo2
+        path=one/two/c.foo
+        path=one/two/three
+        path=one/two/three/d.foo
+        path=one/two/three/directory_foo
+        path=symlink",
+    );
+
+    te.assert_output(
+        &["foo", "--format", "noExt={.}", "--path-separator=/"],
+        "noExt=a
+        noExt=one/b
+        noExt=one/two/C
+        noExt=one/two/c
+        noExt=one/two/three/d
+        noExt=one/two/three/directory_foo",
+    );
+
+    te.assert_output(
+        &["foo", "--format", "basename={/}", "--path-separator=/"],
+        "basename=a.foo
+        basename=b.foo
+        basename=C.Foo2
+        basename=c.foo
+        basename=d.foo
+        basename=directory_foo",
+    );
+
+    te.assert_output(
+        &["foo", "--format", "name={/.}", "--path-separator=/"],
+        "name=a
+        name=b
+        name=C
+        name=c
+        name=d
+        name=directory_foo",
+    );
+
+    te.assert_output(
+        &["foo", "--format", "parent={//}", "--path-separator=/"],
+        "parent=.
+        parent=one
+        parent=one/two
+        parent=one/two
+        parent=one/two/three
+        parent=one/two/three",
+    );
+}
+
 /// Shell script execution (--exec)
 #[test]
 fn test_exec() {
@@ -1635,7 +1772,7 @@ fn test_exec() {
                {abs_path}/one/two/c.foo
                {abs_path}/one/two/three/d.foo
                {abs_path}/one/two/three/directory_foo",
-                abs_path = &abs_path
+                abs_path = abs_path
            ),
        );

@@ -1703,12 +1840,10 @@ fn test_exec() {
    }
 }

+// TODO test for windows
+#[cfg(not(windows))]
 #[test]
 fn test_exec_multi() {
-    // TODO test for windows
-    if cfg!(windows) {
-        return;
-    }
    let (te, abs_path) = get_test_env_with_abs_path(DEFAULT_DIRS, DEFAULT_FILES);

    te.assert_output(
@@ -1736,7 +1871,7 @@ fn test_exec_multi() {
                test c.foo
                test d.foo
                test directory_foo",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );

@@ -1751,9 +1886,11 @@ fn test_exec_multi() {
        e1 e2",
    );

+    // We use printf here because we need to suppress a newline and
+    // echo -n is not POSIX-compliant.
    te.assert_output(
        &[
-            "foo", "--exec", "echo", "-n", "{/}: ", ";", "--exec", "echo", "{//}",
+            "foo", "--exec", "printf", "%s", "{/}: ", ";", "--exec", "printf", "%s\\n", "{//}",
        ],
        "a.foo: .
        b.foo: ./one
@@ -1764,6 +1901,21 @@ fn test_exec_multi() {
    );
 }

+#[cfg(not(windows))]
+#[test]
+fn test_exec_nulls() {
+    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
+    te.assert_output(
+        &["foo", "--print0", "--exec", "printf", "p=%s"],
+        "p=./a.fooNULL
+        p=./one/b.fooNULL
+        p=./one/two/C.Foo2NULL
+        p=./one/two/c.fooNULL
+        p=./one/two/three/d.fooNULL
+        p=./one/two/three/directory_fooNULL",
+    );
+}
+
 #[test]
 fn test_exec_batch() {
    let (te, abs_path) = get_test_env_with_abs_path(DEFAULT_DIRS, DEFAULT_FILES);
@@ -1775,7 +1927,7 @@ fn test_exec_batch() {
            &["--absolute-path", "foo", "--exec-batch", "echo"],
            &format!(
                "{abs_path}/a.foo {abs_path}/one/b.foo {abs_path}/one/two/C.Foo2 {abs_path}/one/two/c.foo {abs_path}/one/two/three/d.foo {abs_path}/one/two/three/directory_foo",
-                abs_path = &abs_path
+                abs_path = abs_path
            ),
        );

@@ -1829,7 +1981,7 @@ fn test_exec_batch() {

        te.assert_failure_with_error(
            &["foo", "--exec-batch", "echo {}"],
-            "error: First argument of exec-batch is expected to be a fixed executable\n\
+            "error: First argument of --exec-batch must be a fixed executable, not a placeholder\n\
            \n\
            Usage: fd [OPTIONS] [pattern] [path]...\n\
            \n\
@@ -2058,14 +2210,57 @@ fn test_fixed_strings() {
    // Regex search, parens are treated as group
    te.assert_output(&["download (1)"], "");

-    // Literal search, parens are treated as characters
+    // Literal search, parens are treated as characters. Case-insensitive by default.
    te.assert_output(
        &["--fixed-strings", "download (1)"],
        "test2/Download (1).tar.gz",
    );

-    // Combine with --case-sensitive
+    // Combine with --case-sensitive (unmatched).
    te.assert_output(&["--fixed-strings", "--case-sensitive", "download (1)"], "");
+
+    // Combine with --case-sensitive (matched).
+    te.assert_output(
+        &["--fixed-strings", "--case-sensitive", "Download (1)"],
+        "test2/Download (1).tar.gz",
+    );
+}
+
+/// Literal search, non-substring (--exact)
+#[test]
+fn test_exact_literal_nonsubstring() {
+    let dirs = &["test1", "test2"];
+    let files = &[
+        "test1/a.foo",
+        "test1/aa.foo",
+        "test1/a.food",
+        "test1/ca.food",
+        "test1/a_foo",
+        "test2/Download (1).tar.gz",
+    ];
+    let te = TestEnv::new(dirs, files);
+
+    // Literal search, dot is treated as character. Should match only the exact name,
+    // not "aa.foo", "a.food", or "ca.food".
+    te.assert_output(&["--exact", "a.foo"], "test1/a.foo");
+
+    // Literal search, parens are treated as characters. Substring should not match.
+    te.assert_output(&["--exact", "download (1)"], "");
+
+    // Literal search, parens are treated as characters. Case-insensitive by default.
+    te.assert_output(
+        &["--exact", "download (1).tar.gz"],
+        "test2/Download (1).tar.gz",
+    );
+
+    // Combine with --case-sensitive, should not match due to case mismatch.
+    te.assert_output(&["--exact", "--case-sensitive", "download (1).tar.gz"], "");
+
+    // Combine with --case-sensitive, exact match should match.
+    te.assert_output(
+        &["--exact", "--case-sensitive", "Download (1).tar.gz"],
+        "test2/Download (1).tar.gz",
+    );
 }

 /// Filenames with invalid UTF-8 sequences
@@ -2227,7 +2422,10 @@ fn test_modified_relative() {

 #[cfg(test)]
 fn change_file_modified<P: AsRef<Path>>(path: P, iso_date: &str) {
-    let st = humantime::parse_rfc3339(iso_date).expect("invalid date");
+    let st = iso_date
+        .parse::<Timestamp>()
+        .map(SystemTime::from)
+        .expect("invalid date");
    let ft = filetime::FileTime::from_system_time(st);
    filetime::set_file_times(path, ft, ft).expect("time modification failde");
 }
@@ -2261,10 +2459,10 @@ fn test_owner_ignore_all() {
 #[test]
 fn test_owner_current_user() {
    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
-    let uid = users::get_current_uid();
+    let uid = Uid::current();
    te.assert_output(&["--owner", &uid.to_string(), "a.foo"], "a.foo");
-    if let Some(username) = users::get_current_username().map(|u| u.into_string().unwrap()) {
-        te.assert_output(&["--owner", &username, "a.foo"], "a.foo");
+    if let Ok(Some(user)) = User::from_uid(uid) {
+        te.assert_output(&["--owner", &user.name, "a.foo"], "a.foo");
    }
 }

@@ -2272,10 +2470,10 @@ fn test_owner_current_user() {
 #[test]
 fn test_owner_current_group() {
    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
-    let gid = users::get_current_gid();
-    te.assert_output(&["--owner", &format!(":{}", gid), "a.foo"], "a.foo");
-    if let Some(groupname) = users::get_current_groupname().map(|u| u.into_string().unwrap()) {
-        te.assert_output(&["--owner", &format!(":{}", groupname), "a.foo"], "a.foo");
+    let gid = Gid::current();
+    te.assert_output(&["--owner", &format!(":{gid}"), "a.foo"], "a.foo");
+    if let Ok(Some(group)) = Group::from_gid(gid) {
+        te.assert_output(&["--owner", &format!(":{}", group.name), "a.foo"], "a.foo");
    }
 }

@@ -2283,7 +2481,7 @@ fn test_owner_current_group() {
 #[test]
 fn test_owner_root() {
    // This test assumes the current user isn't root
-    if users::get_current_uid() == 0 || users::get_current_gid() == 0 {
+    if Uid::current().is_root() || Gid::current() == Gid::from_raw(0) {
        return;
    }
    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
@@ -2341,7 +2539,7 @@ fn test_base_directory() {

    // Ignore base directory when absolute path is used
    let (te, abs_path) = get_test_env_with_abs_path(DEFAULT_DIRS, DEFAULT_FILES);
-    let abs_base_dir = &format!("{abs_path}/one/two/", abs_path = &abs_path);
+    let abs_base_dir = &format!("{abs_path}/one/two/", abs_path = abs_path);
    te.assert_output(
        &["--base-directory", abs_base_dir, "foo", &abs_path],
        &format!(
@@ -2351,7 +2549,7 @@ fn test_base_directory() {
            {abs_path}/one/two/C.Foo2
            {abs_path}/one/two/three/d.foo
            {abs_path}/one/two/three/directory_foo/",
-            abs_path = &abs_path
+            abs_path = abs_path
        ),
    );
 }
@@ -2385,7 +2583,7 @@ fn test_max_results() {
    assert_just_one_result_with_option("--max-results=1");
    assert_just_one_result_with_option("-1");

-    // check that --max-results & -1 conflic with --exec
+    // check that --max-results & -1 conflict with --exec
    te.assert_failure(&["thing", "--max-results=0", "--exec=cat"]);
    te.assert_failure(&["thing", "-1", "--exec=cat"]);
    te.assert_failure(&["thing", "--max-results=1", "-1", "--exec=cat"]);
@@ -2463,6 +2661,7 @@ fn test_number_parsing_errors() {
    te.assert_failure(&["--threads=0"]);

    te.assert_failure(&["--min-depth=a"]);
+    te.assert_failure(&["--mindepth=a"]);
    te.assert_failure(&["--max-depth=a"]);
    te.assert_failure(&["--maxdepth=a"]);
    te.assert_failure(&["--exact-depth=a"]);
@@ -2535,7 +2734,7 @@ fn test_strip_cwd_prefix() {
 /// When fd is ran from a non-existent working directory, but an existent
 /// directory is passed in the arguments, it should still run fine
 #[test]
-#[cfg(not(windows))]
+#[cfg(all(not(windows), not(target_os = "illumos")))]
 fn test_invalid_cwd() {
    let te = TestEnv::new(&[], &[]);

@@ -2551,6 +2750,129 @@ fn test_invalid_cwd() {
        .unwrap();

    if !output.status.success() {
-        panic!("{:?}", output);
+        panic!("{output:?}");
    }
 }
+
+/// Test behavior of .git directory with various flags
+#[test]
+fn test_git_dir() {
+    let te = TestEnv::new(
+        &[".git/one", "other_dir/.git", "nested/dir/.git"],
+        &[
+            ".git/one/foo.a",
+            ".git/.foo",
+            ".git/a.foo",
+            "other_dir/.git/foo1",
+            "nested/dir/.git/foo2",
+        ],
+    );
+
+    te.assert_output(
+        &["--hidden", "foo"],
+        ".git/one/foo.a
+        .git/.foo
+        .git/a.foo
+        other_dir/.git/foo1
+        nested/dir/.git/foo2",
+    );
+    te.assert_output(&["--no-ignore", "foo"], "");
+    te.assert_output(
+        &["--hidden", "--no-ignore", "foo"],
+        ".git/one/foo.a
+         .git/.foo
+         .git/a.foo
+         other_dir/.git/foo1
+         nested/dir/.git/foo2",
+    );
+    te.assert_output(
+        &["--hidden", "--no-ignore-vcs", "foo"],
+        ".git/one/foo.a
+         .git/.foo
+         .git/a.foo
+         other_dir/.git/foo1
+         nested/dir/.git/foo2",
+    );
+}
+
+#[test]
+fn test_gitignore_parent() {
+    let te = TestEnv::new(&["sub"], &[".abc", "sub/.abc"]);
+
+    fs::File::create(te.test_root().join(".gitignore"))
+        .unwrap()
+        .write_all(b".abc\n")
+        .unwrap();
+
+    te.assert_output_subdirectory("sub", &["--hidden"], "");
+    te.assert_output_subdirectory("sub", &["--hidden", "--search-path", "."], "");
+}
+
+#[test]
+fn test_hyperlink() {
+    let te = TestEnv::new(DEFAULT_DIRS, DEFAULT_FILES);
+
+    #[cfg(unix)]
+    let hostname = nix::unistd::gethostname().unwrap().into_string().unwrap();
+    #[cfg(not(unix))]
+    let hostname = "/";
+
+    let expected = format!(
+        "\x1b]8;;file://{}{}/a.foo\x1b\\a.foo\x1b]8;;\x1b\\",
+        hostname,
+        get_absolute_root_path(&te),
+    );
+
+    te.assert_output(&["--hyperlink=always", "a.foo"], &expected);
+}
+
+#[test]
+fn test_ignore_contain() {
+    let te = TestEnv::new(
+        &["include", "exclude", "exclude/sub", "other"],
+        &[
+            "top",
+            "include/foo",
+            "exclude/CACHEDIR.TAG",
+            "exclude/sub/nope",
+            "other/ignoremyparent",
+        ],
+    );
+    let expected = "include/
+    include/foo
+    symlink
+    top";
+    te.assert_output(
+        &[
+            "--ignore-contain=CACHEDIR.TAG",
+            "--ignore-contain=ignoremyparent",
+            ".",
+        ],
+        expected,
+    );
+}
+
+#[test]
+fn test_ignore_contain_precedence_over_depth_check() {
+    let te = TestEnv::new(
+        &["include", "exclude", "exclude/sub"],
+        &[
+            "top",
+            "include/foo",
+            "exclude/CACHEDIR.TAG",
+            "exclude/sub/nope",
+        ],
+    );
+    let expected = "include/foo";
+    te.assert_output(
+        &["--ignore-contain=CACHEDIR.TAG", "--min-depth=2", "."],
+        expected,
+    );
+}
+
+#[test]
+fn test_ignore_contain_precedence_over_root_check() {
+    let te = TestEnv::new(&["include"], &["CACHEDIR.TAG", "top", "include/foo"]);
+    let expected = "";
+    te.assert_output(&["--ignore-contain=CACHEDIR.TAG", "."], expected);
+}