fix pipeline breaks

updated github release pipeline
created a automatic release ci pipeline
2026-08-26 10:05:32 +00:00 · 2025-07-19 13:41:52 +00:00 · 2025-07-19 12:15:42 +00:00 · 2025-07-19 12:00:25 +00:00 · 2025-07-19 11:43:26 +00:00 · 2025-07-19 11:33:52 +00:00
15 changed files with 1711 additions and 1083 deletions
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,136 +1,121 @@
-# CI that:
-#
-# * checks for a Git Tag that looks like a release ("v1.2.0")
-# * creates a Github Release™️
-# * builds binaries/packages with cargo-dist
-# * uploads those packages to the Github Release™️
-#
-# Note that the Github Release™️ will be created before the packages,
-# so there will be a few minutes where the release has no packages
-# and then they will slowly trickle in, possibly failing. To make
-# this more pleasant we mark the release as a "draft" until all
-# artifacts have been successfully uploaded. This allows you to
-# choose what to do with partial successes and avoids spamming
-# anyone with notifications before the release is actually ready.
-name: Release
+name: Deduplicator Release Build CI Pipeline

-permissions:
-  contents: write
-
-# This task will run whenever you push a git tag that looks like
-# a version number. We just look for `v` followed by at least one number
-# and then whatever. so `v1`, `v1.0.0`, and `v1.0.0-prerelease` all work.
-#
-# If there's a prerelease-style suffix to the version then the Github Release™️
-# will be marked as a prerelease (handled by taiki-e/create-gh-release-action).
-#
-# Note that when generating links to uploaded artifacts, cargo-dist will currently
-# assume that your git tag is always v{VERSION} where VERSION is the version in
-# the published package's Cargo.toml (this is the default behaviour of cargo-release).
-# In the future this may be made more robust/configurable.
 on:
  push:
    tags:
-      - v[0-9]+.*
-
-env:
-  ALL_CARGO_DIST_TARGET_ARGS: --target=x86_64-unknown-linux-gnu --target=x86_64-apple-darwin --target=x86_64-pc-windows-msvc 
-  ALL_CARGO_DIST_INSTALLER_ARGS: 
+      - 'v*.*.*'

 jobs:
-  # Create the Github Release™️ so the packages have something to be uploaded to
-  create-release:
+  lint_test:
    runs-on: ubuntu-latest
-    outputs:
-      tag: ${{ steps.create-gh-release.outputs.computed-prefix }}${{ steps.create-gh-release.outputs.version }}
+    env:
+      RUSTFLAGS: "-C target-feature=+aes,+sse2"
    steps:
-      - uses: actions/checkout@v3
-      - id: create-gh-release
-        uses: taiki-e/create-gh-release-action@v1
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
        with:
-          draft: true
-          # (required) GitHub token for creating GitHub Releases.
-          token: ${{ secrets.GITHUB_TOKEN }}
+          components: clippy

+      - name: Run cargo check
+        run: cargo check

-  # Build and packages all the things
-  upload-artifacts:
-    needs: create-release
+      - name: Run cargo clippy
+        run: cargo clippy -- -D warnings
+
+      - name: Run tests
+        run: cargo test -- --test-threads=1
+
+  build:
+    needs: lint_test
+    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        # For these target platforms
        include:
-        - target: x86_64-unknown-linux-gnu
-          os: ubuntu-20.04
-          install-dist: curl --proto '=https' --tlsv1.2 -L -sSf https://github.com/axodotdev/cargo-dist/releases/download/v0.0.2/installer.sh | sh
-        - target: x86_64-apple-darwin
-          os: macos-11
-          install-dist: curl --proto '=https' --tlsv1.2 -L -sSf https://github.com/axodotdev/cargo-dist/releases/download/v0.0.2/installer.sh | sh
-        - target: x86_64-pc-windows-msvc
-          os: windows-2019
-          install-dist: irm 'https://github.com/axodotdev/cargo-dist/releases/download/v0.0.2/installer.ps1' | iex
-    runs-on: ${{ matrix.os }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          - target: aarch64-unknown-linux-gnu
+            os: ubuntu-latest
+            artifact_name: linux-aarch64
+            rustflags: "-C target-feature=+aes,+neon"
+          - target: x86_64-unknown-linux-gnu
+            os: ubuntu-latest
+            artifact_name: linux-amd64
+            rustflags: "-C target-feature=+aes,+sse2"
+          - target: x86_64-apple-darwin
+            os: macos-14
+            artifact_name: macos-amd64
+            rustflags: "-C target-feature=+aes,+sse2"
+          - target: aarch64-apple-darwin
+            os: macos-14
+            artifact_name: macos-arm64
+            rustflags: "-C target-feature=+aes,+neon"
+
    steps:
-      - uses: actions/checkout@v3
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
      - name: Install Rust
-        run: rustup update stable && rustup default stable
-      - name: Install cargo-dist
-        run: ${{ matrix.install-dist }}
-      - name: Run cargo-dist
-        # This logic is a bit janky because it's trying to be a polyglot between
-        # powershell and bash since this will run on windows, macos, and linux!
-        # The two platforms don't agree on how to talk about env vars but they
-        # do agree on 'cat' and '$()' so we use that to marshal values between commmands.
-        run: |
-          # Actually do builds and make zips and whatnot
-          cargo dist --target=${{ matrix.target }} --output-format=json > dist-manifest.json
-          echo "dist ran successfully"
-          cat dist-manifest.json
-          # Parse out what we just built and upload it to the Github Release™️
-          cat dist-manifest.json | jq --raw-output ".releases[].artifacts[].path" > uploads.txt
-          echo "uploading..."
-          cat uploads.txt
-          gh release upload ${{ needs.create-release.outputs.tag }} $(cat uploads.txt)
-          echo "uploaded!"
+        uses: dtolnay/rust-toolchain@stable

-  # Compute and upload the manifest for everything
-  upload-manifest:
-    needs: create-release
+      - name: Add target
+        run: rustup target add ${{ matrix.target }}
+
+      - name: Install cross-compilation toolchain (Linux ARM only)
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+
+      - name: Build release binary
+        env:
+          RUSTFLAGS: ${{ matrix.rustflags }}
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: ${{ matrix.target == 'aarch64-unknown-linux-gnu' && 'aarch64-linux-gnu-gcc' || '' }}
+        run: |
+          if [ "${{ matrix.target }}" = "aarch64-unknown-linux-gnu" ]; then
+            export CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
+          fi
+          cargo build --release --target ${{ matrix.target }}
+
+      - name: Package binary
+        run: |
+          if [[ "${{ matrix.os }}" == macos* ]]; then
+            BINARY_NAME=$(find target/${{ matrix.target }}/release -maxdepth 1 -type f -perm +111 -print0 | xargs -0 basename | head -1)
+          else
+            BINARY_NAME=$(find target/${{ matrix.target }}/release -maxdepth 1 -type f -executable -print0 | xargs -0 basename | head -1)
+          fi
+          
+          echo "Packaging binary: $BINARY_NAME"
+          mkdir -p release
+          cp target/${{ matrix.target }}/release/$BINARY_NAME release/$BINARY_NAME
+          tar -C release -czf ${{ matrix.artifact_name }}.tar.gz $BINARY_NAME
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact_name }}-binary
+          path: ${{ matrix.artifact_name }}.tar.gz
+
+  create_release:
+    needs: build
    runs-on: ubuntu-latest
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust
-        run: rustup update stable && rustup default stable
-      - name: Install cargo-dist
-        run: curl --proto '=https' --tlsv1.2 -L -sSf https://github.com/axodotdev/cargo-dist/releases/download/v0.0.2/installer.sh | sh
-      - name: Run cargo-dist manifest
-        run: |
-          # Generate a manifest describing everything
-          cargo dist manifest --no-local-paths --output-format=json $ALL_CARGO_DIST_TARGET_ARGS $ALL_CARGO_DIST_INSTALLER_ARGS > dist-manifest.json
-          echo "dist manifest ran successfully"
-          cat dist-manifest.json
-          # Upload the manifest to the Github Release™️
-          gh release upload ${{ needs.create-release.outputs.tag }} dist-manifest.json
-          echo "uploaded manifest!"
-          # Edit the Github Release™️ title/body to match what cargo-dist thinks it should be
-          CHANGELOG_TITLE=$(cat dist-manifest.json | jq --raw-output ".releases[].changelog_title")
-          cat dist-manifest.json | jq --raw-output ".releases[].changelog_body" > new_dist_changelog.md
-          gh release edit ${{ needs.create-release.outputs.tag }} --title="$CHANGELOG_TITLE" --notes-file=new_dist_changelog.md
-          echo "updated release notes!"
+      - name: Checkout repository
+        uses: actions/checkout@v4

-  # Mark the Github Release™️ as a non-draft now that everything has succeeded!
-  publish-release:
-    needs: [create-release, upload-artifacts, upload-manifest]
-    runs-on: ubuntu-latest
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: mark release as non-draft
-        run: |
-          gh release edit ${{ needs.create-release.outputs.tag }} --draft=false
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts

+      - name: Create GitHub Release
+        id: create_release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ github.ref_name }}
+          name: Release ${{ github.ref_name }}
+          body: "Automated release for version ${{ github.ref_name }}"
+          files: |
+            artifacts/*/*.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
 /target
 /Cargo.lock
+/result-bin
+/.bacon-locations
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,36 +1,58 @@
 [package]
 name = "deduplicator"
-version = "0.2.0"
+version = "0.3.1"
 edition = "2021"
-description = "find,filter,delete Duplicates"
+description = "find,filter and delete duplicate files"
+repository = "https://github.com/sreedevk/deduplicator"
 license = "MIT"
 authors = [
-    "Sreedev Kodichath <sreedevpadmakumar@gmail.com>",
-    "Valentin Bersier <vbersier@gmail.com>",
-    "Dhruva Sagar <dhruva.sagar@gmail.com>",
+  "Sreedev Kodichath <sreedevpadmakumar@gmail.com>",
+  "Valentin Bersier <vbersier@gmail.com>",
+  "Dhruva Sagar <dhruva.sagar@gmail.com>",
 ]

-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[[bin]]
+name = "deduplicator"
+path = "src/main.rs"

+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 anyhow = "1.0.68"
-bytesize = "1.1.0"
+bytesize = "2.0.1"
 chrono = "0.4.23"
 clap = { version = "4.0.32", features = ["derive"] }
-colored = "2.0.0"
-dashmap = { version = "5.4.0", features = ["rayon"] }
-fxhash = "0.2.1"
-globwalk = "0.8.1"
-indicatif = { version = "0.17.2", features = ["rayon"] }
-itertools = "0.10.5"
-memmap2 = "0.5.8"
+dashmap = { version = "6.1.0", features = ["rayon"] }
+globwalk = "0.9.1"
+gxhash = { version = "3.4.1", default-features = false }
+indicatif = { version = "0.18.0", features = ["rayon"] }
+memmap2 = "0.9.7"
 pathdiff = "0.2.1"
 prettytable-rs = "0.10.0"
+rand = "0.9.1"
 rayon = "1.6.1"
-unicode-segmentation = "1.10.0"
+threadpool = "1.8.1"
+
+[profile.release]
+strip = true
+opt-level = 3
+lto = "thin"
+debug = false
+codegen-units = 1

 # generated by 'cargo dist init'
 [profile.dist]
 inherits = "release"
-debug = true
-split-debuginfo = "packed"
+
+[workspace.metadata.dist]
+rust-toolchain-version = "1.87.0"
+ci = ["github"]
+targets = [
+  "x86_64-unknown-linux-gnu",
+  "x86_64-apple-darwin",
+  "x86_64-pc-windows-msvc",
+  "aarch64-apple-darwin",
+]
+cargo-dist-version = "0.0.7"
+
+[dev-dependencies]
+tempfile = "3.20.0"
--- a/README.md
+++ b/README.md
@@ -7,20 +7,25 @@
 ## Usage

 ```bash
+find,filter and delete duplicate files
+
 Usage: deduplicator [OPTIONS] [scan_dir_path]

 Arguments:
  [scan_dir_path]  Run Deduplicator on dir different from pwd (e.g., ~/Pictures )

 Options:
-  -t, --types <TYPES>          Filetypes to deduplicate [default = all]
-  -i, --interactive            Delete files interactively
-  -s, --min-size <MIN_SIZE>    Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T) [default: 1b]
-  -d, --max-depth <MAX_DEPTH>  Max Depth to scan while looking for duplicates
-      --min-depth <MIN_DEPTH>  Min Depth to scan while looking for duplicates
-  -f, --follow-links           Follow links while scanning directories
-  -h, --help                   Print help information
-  -V, --version                Print version information
+  -T, --exclude-types <EXCLUDE_TYPES>  Exclude Filetypes [default = none]
+  -t, --types <TYPES>                  Filetypes to deduplicate [default = all]
+  -i, --interactive                    Delete files interactively
+  -m, --min-size <MIN_SIZE>            Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T) [default: 1b]
+  -D, --max-depth <MAX_DEPTH>          Max Depth to scan while looking for duplicates
+  -d, --min-depth <MIN_DEPTH>          Min Depth to scan while looking for duplicates
+  -f, --follow-links                   Follow links while scanning directories
+  -s, --strict                         Guarantees that two files are duplicate (performs a full hash)
+  -p, --progress                       Show Progress spinners & metrics
+  -h, --help                           Print help
+  -V, --version                        Print version
 ```
 ### Examples

@@ -28,6 +33,9 @@ Options:
 # Scan for duplicates recursively from the current dir, only look for png, jpg & pdf file types & interactively delete files
 deduplicator -t pdf,jpg,png -i

+# Scan for duplicates recursively from current dir, exclude png and jpg file types
+deduplicator -T jpg,png
+
 # Scan for duplicates recursively from the ~/Pictures dir, only look for png, jpeg, jpg & pdf file types & interactively delete files
 deduplicator ~/Pictures/ -t png,jpeg,jpg,pdf -i

@@ -41,83 +49,148 @@ deduplicator ~/.config --follow-links
 deduplicator ~/Media --min-size 100mb
 ```

+## Demo
+![record](https://github.com/user-attachments/assets/fcfdd9bf-4d05-41b6-a82e-367634eeaa73)
+
+
+
 ## Installation
+Currently, you can only install deduplicator using cargo package manager.

-### Cargo Install
+### Cargo
+> GxHash relies on aes hardware acceleration, so please set `RUSTFLAGS` to `"-C target-feature=+aes"` or `"-C target-cpu=native"` before
+> installing.

-#### Stable
+#### install from crates.io (stable)

 ```bash
-$ cargo install deduplicator
+$ RUSTFLAGS="-C target-cpu=native" cargo install deduplicator
+
+# or
+
+$ RUSTFLAGS="-C target-feature=+aes,+sse2" cargo install deduplicator
 ```

-#### Nightly
-
-if you'd like to install with nightly features, you can use
-
+#### install from git (nightly)
 ```bash
-$ cargo install --git https://github.com/sreedevk/deduplicator
+$ RUSTFLAGS="-C target-cpu=native" cargo install deduplicator --git https://github.com/sreedevk/deduplicator
+
+# or
+
+$ RUSTFLAGS="-C target-feature=+aes,+sse2" cargo install --git https://github.com/sreedevk/deduplicator
 ```
-Please note that if you use a version manager to install rust (like asdf), you need to reshim (`asdf reshim rust`).
-
-### Linux (Pre-built Binary)
-
-you can download the pre-built binary from the [Releases](https://github.com/sreedevk/deduplicator/releases) page.
-download the `deduplicator-x86_64-unknown-linux-gnu.tar.gz` for linux. Once you have the tarball file with the executable,
-you can follow these steps to install:
-
-```bash
-$ tar -zxvf deduplicator-x86_64-unknown-linux-gnu.tar.gz
-$ sudo mv deduplicator /usr/bin/
-```
-
-### Mac OS (Pre-built Binary)
-
-you can download the pre-build binary from the [Releases](https://github.com/sreedevk/deduplicator/releases) page.
-download the `deduplicator-x86_64-apple-darwin.tar.gz` tarball for mac os. Once you have the tarball file with the executable, you can follow these steps to install:
-
-```bash
-$ tar -zxvf deduplicator-x86_64-unknown-linux-gnu.tar.gz
-$ sudo mv deduplicator /usr/bin/
-```
-
-### Windows (Pre-built Binary)
-
-you can download the pre-build binary from the [Releases](https://github.com/sreedevk/deduplicator/releases) page.
-download the `deduplicator-x86_64-pc-windows-msvc.zip` zip file for windows. unzip the `zip`  file & move the `deduplicator.exe` to a location in the PATH system environment variable.
-
-Note: If you Run into an msvc error, please install MSCV from [here](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170)

 ## Performance
+Deduplicator uses size comparison and [GxHash](https://docs.rs/gxhash/latest/gxhash/) to quickly check a large number of files to find duplicates. its also heavily parallelized. The default behavior of deduplicator is to only hash the first page (4K) of the file. This is to ensure that performance is the default priority. You can modify this behavior by using the `--strict` flag which will hash the whole file and ensure that 2 files are indeed duplicates. I'll add benchmarks in future versions.

-Deduplicator uses size comparison and fxhash (a non non-cryptographic hashing algo) to quickly scan through large number of files to find duplicates. its also highly parallel (uses rayon and dashmap). I was able to scan through 120GB of files (Videos, PDFs, Images) in ~300ms. checkout the benchmarks
-
-## benchmarks
-
-| Command | Dirsize | Filecount | Mean [ms] | Min [ms] | Max [ms] | Relative |
-|:---|:---|---:|---:|---:|---:|---:|
-| `deduplicator ~/Data/tmp` | (~120G) | 721 files | 33.5 ± 28.6 | 25.3 | 151.5 | 1.87 ± 1.60 |
-| `deduplicator ~/Data/books` | (~8.6G) | 1419 files | 24.5 ± 1.0 | 22.9 | 28.1 | 1.37 ± 0.08 |
-| `deduplicator ~/Data/books --min-size 10M` | (~8.6G) | 1419 files | 17.9 ± 0.7 | 16.8 | 20.0 | 1.00 |
-| `deduplicator ~/Data/ --types pdf,jpg,png,jpeg` | (~290G) | 104222 files | 1207.2 ± 37.0 | 1172.2 | 1287.7 | 67.27 ± 3.33 |
-
-* The last entry is lower because of the number of files deduplicator had to go through (~660895 Files). The average size of the files rarely affect the performance of deduplicator.
-
-These benchmarks were run using [hyperfine](https://github.com/sharkdp/hyperfine). Here are the specs of the machine used to benchmark deduplicator:
+### Benchmarks
+I've used hyperfine to run deduplicator on files generated by the rake file at `rakelib/benchmark.rake`. The Benchmarking accuracy can further be improved by isolating runs inside restricted docker containers. I'll include that in the future. For now, here's the hyperfine output on my i7-12800H laptop with 32G of RAM.

+#### Fewer Large Files
 ```
-OS: Arch Linux x86_64 
-Host: Precision 5540
-Kernel: 5.15.89-1-lts 
-Uptime: 4 hours, 44 mins 
-Shell: zsh 5.9                        
-Terminal: kitty 
-CPU: Intel i9-9880H (16) @ 4.800GHz 
-GPU: NVIDIA Quadro T2000 Mobile / Max-Q 
-GPU: Intel CoffeeLake-H GT2 [UHD Graphics 630] 
-Memory: 31731MiB (~32GiB)
+# hyperfine -N --warmup 80 './target/release/deduplicator bench_artifacts'
+Benchmark 1: ./target/release/deduplicator bench_artifacts
+  Time (mean ± σ):       2.2 ms ±   0.4 ms    [User: 2.2 ms, System: 4.4 ms]
+  Range (min … max):     1.3 ms …   7.1 ms    1522 runs
+
+dust 'bench_artifacts'
+
+ 54M   ┌── file_0_fwds.bin   │████                                                               │   2%
+122M   ├── file_1_fwds.bin   │████████                                                           │   5%
+390M   ├── file_0_fwdcbss.bin│██████████████████████████                                         │  15%
+390M   ├── file_0_fwscas.bin │██████████████████████████                                         │  15%
+390M   ├── file_0_fwss.bin   │██████████████████████████                                         │  15%
+390M   ├── file_1_fwdcbss.bin│██████████████████████████                                         │  15%
+390M   ├── file_1_fwscas.bin │██████████████████████████                                         │  15%
+390M   ├── file_1_fwss.bin   │██████████████████████████                                         │  15%
+2.5G ┌─┴ bench_artifacts     │██████████████████████████████████████████████████████████████████ │ 100%
 ```

-## Screenshots
+#### Many Small Files
+```
+# hyperfine --warmup 20 './target/release/deduplicator bench_artifacts'
+Benchmark 1: ./target/release/deduplicator bench_artifacts
+  Time (mean ± σ):      40.1 ms ±   2.3 ms    [User: 251.0 ms, System: 277.3 ms]
+  Range (min … max):    35.0 ms …  45.9 ms    72 runs

-![](https://user-images.githubusercontent.com/36154121/213618143-e5182e39-731e-4817-87dd-1a6a0f38a449.gif)
+dust 'bench_artifacts'
+3.9M   ┌── file_992_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_992_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_993_fwdcbss.bin│█                                                                │   0%
+3.9M   ├── file_993_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_993_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_994_fwdcbss.bin│█                                                                │   0%
+3.9M   ├── file_994_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_994_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_995_fwdcbss.bin│█                                                                │   0%
+3.9M   ├── file_995_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_995_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_996_fwdcbss.bin│█                                                                │   0%
+3.9M   ├── file_996_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_996_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_997_fwdcbss.bin│█                                                                │   0%
+3.9M   ├── file_997_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_997_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_998_fwdcbss.bin│█                                                                │   0%
+3.9M   ├── file_998_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_998_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_999_fwdcbss.bin│█                                                                │   0%
+3.9M   ├── file_999_fwscas.bin │█                                                                │   0%
+3.9M   ├── file_999_fwss.bin   │█                                                                │   0%
+3.9M   ├── file_99_fwdcbss.bin │█                                                                │   0%
+3.9M   ├── file_99_fwscas.bin  │█                                                                │   0%
+3.9M   ├── file_99_fwss.bin    │█                                                                │   0%
+3.9M   ├── file_9_fwdcbss.bin  │█                                                                │   0%
+3.9M   ├── file_9_fwscas.bin   │█                                                                │   0%
+3.9M   ├── file_9_fwss.bin     │█                                                                │   0%
+ 11G ┌─┴ bench_artifacts       │████████████████████████████████████████████████████████████████ │ 100%
+```
+
+## proposed
+- [ ] parallelization
+    - [ ] scanning + processing sw + processing hw + formatting + printing
+- [ ] max file path size should use the last set of duplicates
+- [ ] add more unit tests
+    - [ ] test against different filesystems
+    - [ ] test against different file name encodings
+- [ ] restore json output (was removed in 0.3 due to quality issues)
+- [ ] fix memory leak on very large filesystems
+    - [ ] maybe use a bloom filter
+    - [ ] reduce FileInfo size
+- [ ] tui
+- [ ] change the default hashing method to include the first & last page of a file (8K)
+- [ ] provide option to localize duplicate detection to arbitrary levels relative to current directory
+- [ ] bulk operations
+    - [ ] --keep-latest
+    - [ ] --keep-oldest
+    - [ ] --keep-last-modified
+    - [ ] --keep-first-modified
+
+- [ ] fix: partial hash collision - a file full of null bytes ("\0") and an empty file. This is a known trade off in gxhash.
+    - [ ] include initial pages and final pages of the file 
+    - [ ] append the offset between the last initial page hashed and the first final page hashed in the content passed to the hasher.
+
+## v0.3.1
+- [x] parallelization
+    - [x] (scanning + processing sw + processing hw) & formatting & printing
+- [x] remove formatting step and write directly to stdout
+- [x] simplify output to improve performance
+- [x] increase the number of pages hashed in partial hashing
+- [x] updated dependencies
+- [x] fix: full file hash collision between a file full of null bytes ("\0") and an empty file. This is a known trade off in gxhash.
+    - [x] appending the file size at the end of content before hashing.
+- [x] created an automated release pipeline
+
+## v0.3.0
+- [x] parallelization
+    - [x] (scanning) + (processing sw & processing hw & formatting & printing)
+- [x] reduce cloning values on the heap
+- [x] add a partial hashing mode (--strict)
+- [x] add unit tests
+- [x] add silent mode
+- [x] update documentation
+- [x] remove color output
+- [x] progress bar improvements
+    - [x] use progress bar groups
+- [x] remove broken json rendering
+- [x] add benchmarks
--- a/1
+++ b/1
@@ -0,0 +1 @@
+# tasks are contained in the `rakelib` directory
--- a/rakelib/benchmark.rake
+++ b/rakelib/benchmark.rake
@@ -0,0 +1,102 @@
+require 'tempfile'
+require 'fileutils'
+require 'securerandom'
+
+namespace :benchmark do
+  file 'target/release/deduplicator' do
+    sh "cargo build --release"
+  end
+
+  task :few_large_files => 'target/release/deduplicator' do
+    # Benchmark 1: ./target/release/deduplicator bench_artifacts
+    # Time (mean ± σ):       2.5 ms ±   0.6 ms    [User: 2.4 ms, System: 4.8 ms]
+    # Range (min … max):     1.8 ms …   9.7 ms    1474 runs
+
+    root = "bench_artifacts"
+    FileUtils.rm_rf(root)
+    Dir.mkdir(root)
+
+    # files with same size
+    puts "generating files of same size ..."
+    2.times.map do |i|
+      File.open(File.join(root, "file_#{i}_fwss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 100_000))
+      end
+    end
+
+    # files with different sizes
+    puts "generating files of different sizes ..."
+    2.times.map do |i|
+      File.open(File.join(root, "file_#{i}_fwds.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * (rand * 100_000).ceil))
+      end
+    end
+
+    # files with same content & size
+    puts "generating files of same content and sizes ..."
+    2.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwscas.bin"), 'wb') do |f|
+        f.write("\0" * (4096 * 100_000))
+      end
+    end
+
+    # files with different content but same size
+    puts "generating files of different content but same sizes ..."
+    2.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwdcbss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 100_000))
+      end
+    end
+
+    sh("hyperfine -N --warmup 80 './target/release/deduplicator #{root}'")
+    sh("dust '#{root}'")
+
+    FileUtils.rm_rf(root)
+  end
+
+  task :many_small_files => 'target/release/deduplicator' do
+    # Benchmark 1: ./target/release/deduplicator bench_artifacts
+    # Time (mean ± σ):      10.6 ms ±   1.0 ms    [User: 20.0 ms, System: 22.5 ms]
+    # Range (min … max):     8.4 ms …  14.2 ms    235 runs
+
+    root = "bench_artifacts"
+    Dir.mkdir(root)
+
+    # files with same size
+    puts "generating 1000 files of the same size ... "
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 1000))
+      end
+    end
+
+    # files with different sizes
+    puts "generating 1000 files of different sizes ... "
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwds.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * (rand * 100).ceil))
+      end
+    end
+
+    # files with same content & size
+    puts "generating files of same content and sizes ..."
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwscas.bin"), 'wb') do |f|
+        f.write("\0" * (4096 * 1000))
+      end
+    end
+
+    # files with different content but same size
+    puts "generating files of different content but same sizes ..."
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwdcbss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 1000))
+      end
+    end
+
+    sh("hyperfine --warmup 20 './target/release/deduplicator #{root}'")
+    sh("dust '#{root}'")
+
+    FileUtils.rm_rf(root)
+  end
+end
--- a/src/fileinfo.rs
+++ b/src/fileinfo.rs
@@ -1,40 +1,104 @@
 use anyhow::Result;
+use gxhash::gxhash128;
 use memmap2::Mmap;
-use std::fs;
-use std::hash::Hasher;
-use std::{fs::Metadata, path::PathBuf};
+use std::{
+    fs,
+    io::Read,
+    path::{Path, PathBuf},
+    sync::{Arc, Mutex},
+    time::SystemTime,
+};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum FileState {
+    Unprocessed,
+    SwProcessed,
+}

 #[derive(Debug, Clone)]
 pub struct FileInfo {
-    pub path: PathBuf,
-    pub filemeta: Metadata,
-    pub hash: Option<String>,
+    pub path: Box<Path>,
    pub size: u64,
+    pub modified: SystemTime,
+    pub state: Arc<Mutex<FileState>>,
 }

 impl FileInfo {
-    pub fn hash(&self) -> Result<Self> {
-        let file = fs::File::open(self.path.clone())?;
+    pub fn hash(&self, seed: i64) -> Result<u128> {
+        if self.size == 0 {
+            return Ok(0u128);
+        };
+
+        let file = fs::File::open(&self.path)?;
        let mapper = unsafe { Mmap::map(&file)? };
-        let mut primhasher = fxhash::FxHasher::default();
+        let content_hash = mapper
+            .chunks(4096)
+            .fold(0u128, |acc, chunk: &[u8]| acc ^ gxhash128(chunk, seed));

-        mapper
-            .chunks(1_000_000)
-            .for_each(|chunk| primhasher.write(chunk));
+        // NOTE: avoids collision bw an empty file & a file full of null bytes.
+        Ok(content_hash ^ gxhash128(&self.size.to_ne_bytes(), seed))
+    }

-        Ok(Self {
-            hash: Some(primhasher.finish().to_string()),
-            ..self.clone()
-        })
+    pub fn initpages_hash(&self, seed: i64) -> Result<u128> {
+        let mut file = fs::File::open(&self.path)?;
+        let mut buffer = [0; 16384];
+        let bytes_read = file.read(&mut buffer)?;
+
+        Ok(gxhash128(&buffer[..bytes_read], seed))
    }

    pub fn new(path: PathBuf) -> Result<Self> {
-        let filemeta = std::fs::metadata(path.clone())?;
+        let filemeta = std::fs::metadata(&path)?;
        Ok(Self {
-            path,
-            filemeta: filemeta.clone(),
-            hash: None,
+            path: path.into_boxed_path(),
            size: filemeta.len(),
+            modified: filemeta.modified()?,
+            state: Arc::new(Mutex::new(FileState::Unprocessed)),
        })
    }
+
+    pub fn sw_processed(&self) {
+        let mut self_state = self.state.lock().unwrap();
+        *self_state = FileState::SwProcessed;
+    }
+
+    pub fn is_sw_processed(&self) -> bool {
+        let self_state = self.state.lock().unwrap();
+        *self_state == FileState::SwProcessed
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use tempfile::TempDir;
+    use std::fs::File;
+    use std::io::Write;
+    use anyhow::Result;
+
+    fn generate_null_bytes(size: usize) -> Vec<u8> {
+        (0..size).map(|_| 0).collect::<Vec<u8>>()
+    }
+
+    #[test]
+    fn hash_differentiates_between_a_file_of_null_bytes_vs_an_empty_file() -> Result<()> {
+        let root = TempDir::new()?;
+        let empty_file_name = root.path().join("empty_file.bin");
+
+        File::create_new(&empty_file_name)?;
+
+        let file_with_null_bytes_name = root.path().join("file_with_null_bytes.bin");
+        let mut file_with_null_bytes = File::create_new(&file_with_null_bytes_name)?;
+
+        file_with_null_bytes.write_all(&generate_null_bytes(1000 * 4096))?;
+
+        let empty_file_info = FileInfo::new(empty_file_name)?;
+        let file_with_empty_bytes_info = FileInfo::new(file_with_null_bytes_name)?;
+
+        let seed: i64 = 246910456374;
+
+        assert_ne!(empty_file_info.hash(seed)?, file_with_empty_bytes_info.hash(seed)?);
+
+        Ok(())
+    }
 }
--- a/src/formatter.rs
+++ b/src/formatter.rs
@@ -1,28 +1,19 @@
-pub struct Formatter;
-use crate::fileinfo::FileInfo;
-use crate::params::Params;
+use crate::{fileinfo::FileInfo, params::Params};
 use anyhow::Result;
 use chrono::{DateTime, Utc};
-use colored::Colorize;
 use dashmap::DashMap;
-use indicatif::{
-    ParallelProgressIterator, ProgressBar, ProgressFinish, ProgressIterator, ProgressStyle,
-};
 use pathdiff::diff_paths;
-use prettytable::{format, row, Table};
 use rayon::prelude::*;
-use std::borrow::Cow;
-use std::path::PathBuf;
-use std::time::Duration;
+use std::{path::PathBuf, sync::Arc};

+const YELLOW: &str = "\x1b[33m";
+const RESET: &str = "\x1b[0m";
+
+pub struct Formatter;
 impl Formatter {
-    pub fn human_path(
-        file: &FileInfo,
-        app_args: &Params,
-        min_path_length: usize,
-    ) -> Result<String> {
-        let base_directory: PathBuf = app_args.get_directory()?;
-        let relative_path = diff_paths(file.path.clone(), base_directory).unwrap_or_default();
+    pub fn human_path(file: &FileInfo, aargs: &Params, min_path_length: usize) -> Result<String> {
+        let base_directory: PathBuf = aargs.get_directory()?;
+        let relative_path = diff_paths(&file.path, base_directory).unwrap_or_default();

        let formatted_path = format!(
            "{:<0width$}",
@@ -38,92 +29,36 @@ impl Formatter {
    }

    pub fn human_mtime(file: &FileInfo) -> Result<String> {
-        let modified_time: DateTime<Utc> = file.filemeta.modified()?.into();
+        let modified_time: DateTime<Utc> = file.modified.into();
        Ok(modified_time.format("%Y-%m-%d %H:%M:%S").to_string())
    }

-    pub fn generate_table(raw: Vec<FileInfo>, app_args: &Params) -> Result<Table> {
-        let basepath_length = app_args.get_directory()?.to_str().unwrap_or_default().len();
-        let max_filepath_length = raw
-            .iter()
-            .map(|file| file.path.to_str().unwrap_or_default().len())
-            .max()
-            .unwrap_or_default();
+    pub fn print(raw: Arc<DashMap<u128, Vec<FileInfo>>>, max_path_len: u64, aargs: &Params) {
+        print!("{}", "\n".repeat(if aargs.progress { 2 } else { 1 })); // spacing

-        let min_path_length = if max_filepath_length > basepath_length {
-            max_filepath_length - basepath_length
-        } else {
-            0
-        };
-
-        let progress_style = ProgressStyle::with_template(
-            "[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
-        )?;
-        let progress_bar = ProgressBar::new(raw.len() as u64);
-        progress_bar.set_style(progress_style);
-        progress_bar.enable_steady_tick(Duration::from_millis(50));
-        progress_bar.set_message("reconciling data");
-
-        let duplicates_table: DashMap<String, Vec<FileInfo>> = DashMap::new();
-        raw.into_par_iter()
-            .progress_with(progress_bar)
-            .with_finish(ProgressFinish::WithMessage(Cow::from("data reconciled")))
-            .map(|file| file.hash())
-            .filter_map(Result::ok)
-            .for_each(|file| {
-                duplicates_table
-                    .entry(file.hash.clone().unwrap_or_default())
-                    .and_modify(|fileset| fileset.push(file.clone()))
-                    .or_insert_with(|| vec![file]);
-            });
-
-        let mut output_table = Table::new();
-        output_table.set_titles(row!["hash", "duplicates"]);
-
-        let progress_style = ProgressStyle::with_template(
-            "[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
-        )?;
-
-        let progress_bar = ProgressBar::new(duplicates_table.len() as u64);
-        progress_bar.set_style(progress_style);
-        progress_bar.enable_steady_tick(Duration::from_millis(50));
-        progress_bar.set_message("generating output");
-
-        duplicates_table
-            .into_iter()
-            .progress_with(progress_bar)
-            .with_finish(ProgressFinish::WithMessage(Cow::from("output generated")))
-            .for_each(|(hash, group)| {
-                let mut inner_table = Table::new();
-                inner_table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
-                group.iter().for_each(|file| {
-                    inner_table.add_row(row![
-                        Self::human_path(file, app_args, min_path_length)
-                            .unwrap_or_default()
-                            .blue(),
-                        Self::human_filesize(file).unwrap_or_default().red(),
-                        Self::human_mtime(file).unwrap_or_default().yellow()
-                    ]);
-                });
-
-                output_table.add_row(row![hash.green(), inner_table]);
-            });
-
-        Ok(output_table)
-    }
-
-    pub fn print(raw: Vec<FileInfo>, app_args: &Params) -> Result<()> {
        if raw.is_empty() {
-            println!(
-                "\n\n{}\n",
-                "No duplicates found matching your search criteria.".green()
-            );
-            return Ok(());
+            println!("No duplicates found matching your search criteria.");
+        } else {
+            raw.par_iter().for_each(|sref| {
+                let mut ostring = format!("{}{:32x}{}\n", YELLOW, sref.key(), RESET);
+                let subfields = sref
+                    .value()
+                    .par_iter()
+                    .map(|finfo| {
+                        format!(
+                            "├─ {}\t{}\t{}\n",
+                            Self::human_path(finfo, aargs, max_path_len as usize)
+                                .expect("path formatting failed."),
+                            Self::human_filesize(finfo).expect("filesize formatting failed."),
+                            Self::human_mtime(finfo).expect("modified time formatting failed.")
+                        )
+                    })
+                    .collect::<String>();
+
+                ostring.push_str(&subfields);
+
+                println!("{ostring}");
+            });
        }
-
-        let output_table = Self::generate_table(raw, app_args)?;
-        output_table.printstd();
-
-        Ok(())
    }
 }
--- a/src/interactive.rs
+++ b/src/interactive.rs
@@ -1,154 +1,125 @@
-use crate::formatter::Formatter;
-use crate::{fileinfo::FileInfo, params::Params};
+use crate::{fileinfo::FileInfo, formatter::Formatter, params::Params};
 use anyhow::Result;
-use colored::Colorize;
 use dashmap::DashMap;
-use indicatif::{ParallelProgressIterator, ProgressBar, ProgressFinish, ProgressStyle};
 use prettytable::{format, row, Table};
-use rayon::prelude::*;
 use std::{
-    borrow::Cow,
    io::{self, Write},
-    time::Duration,
+    sync::Arc,
 };

-pub fn scan_group_confirmation() -> Result<bool> {
-    print!("\nconfirm? [y/N]: ");
-    std::io::stdout().flush()?;
-    let mut user_input = String::new();
-    io::stdin().read_line(&mut user_input)?;
+pub struct Interactive;

-    match user_input.trim() {
-        "Y" | "y" => Ok(true),
-        _ => Ok(false),
-    }
-}
+impl Interactive {
+    pub fn init(result: Arc<DashMap<u128, Vec<FileInfo>>>, app_args: &Params) -> Result<()> {
+        result
+            .clone()
+            .iter()
+            .filter(|i| i.value().len() > 1)
+            .enumerate()
+            .for_each(|(gindex, i)| {
+                let group = i.value();
+                let mut itable = Table::new();
+                itable.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
+                itable.set_titles(row!["index", "filename", "size", "updated_at"]);

-pub fn scan_group_instruction() -> Result<String> {
-    println!("\nEnter the indices of the files you want to delete.");
-    println!("You can enter multiple files using commas to seperate file indices.");
-    println!("example: 1,2");
-    print!("\n> ");
-    std::io::stdout().flush()?;
-    let mut user_input = String::new();
-    io::stdin().read_line(&mut user_input)?;
+                let max_path_size = group
+                    .iter()
+                    .map(|f| f.path.iter().count())
+                    .max()
+                    .unwrap_or_default();

-    Ok(user_input)
-}
+                group.iter().enumerate().for_each(|(index, file)| {
+                    itable.add_row(row![
+                        index,
+                        Formatter::human_path(file, app_args, max_path_size).unwrap_or_default(),
+                        Formatter::human_filesize(file).unwrap_or_default(),
+                        Formatter::human_mtime(file).unwrap_or_default()
+                    ]);
+                });

-pub fn init(result: Vec<FileInfo>, app_args: &Params) -> Result<()> {
-    let basepath_length = app_args.get_directory()?.to_str().unwrap_or_default().len();
-    let max_filepath_length = result
-        .iter()
-        .map(|file| file.path.to_str().unwrap_or_default().len())
-        .max()
-        .unwrap_or_default();
-
-    let min_path_length = if max_filepath_length > basepath_length {
-        max_filepath_length - basepath_length
-    } else {
-        0
-    };
-
-    let progress_style = ProgressStyle::with_template(
-        "[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
-    )?;
-    let progress_bar = ProgressBar::new(result.len() as u64);
-    progress_bar.set_style(progress_style);
-    progress_bar.enable_steady_tick(Duration::from_millis(50));
-    progress_bar.set_message("reconciling data");
-
-    let duplicates: DashMap<String, Vec<FileInfo>> = DashMap::new();
-    result
-        .into_par_iter()
-        .progress_with(progress_bar)
-        .with_finish(ProgressFinish::WithMessage(Cow::from("data reconciled")))
-        .map(|file| file.hash())
-        .filter_map(Result::ok)
-        .for_each(|file| {
-            duplicates
-                .entry(file.hash.clone().unwrap_or_default())
-                .and_modify(|fileset| fileset.push(file.clone()))
-                .or_insert_with(|| vec![file]);
-        });
-
-    duplicates
-        .clone()
-        .into_iter()
-        .enumerate()
-        .for_each(|(gindex, (_, group))| {
-            let mut itable = Table::new();
-            itable.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
-            itable.set_titles(row!["index", "filename", "size", "updated_at"]);
-            group.iter().enumerate().for_each(|(index, file)| {
-                itable.add_row(row![
-                    index,
-                    Formatter::human_path(file, app_args, min_path_length)
-                        .unwrap_or_default()
-                        .blue(),
-                    Formatter::human_filesize(file).unwrap_or_default().red(),
-                    Formatter::human_mtime(file).unwrap_or_default().yellow()
-                ]);
+                Self::process_group_action(group, gindex, result.len(), itable);
            });

-            process_group_action(&group, gindex, duplicates.len(), itable);
-        });
-
-    Ok(())
-}
-
-pub fn process_group_action(
-    duplicates: &Vec<FileInfo>,
-    dup_index: usize,
-    dup_size: usize,
-    table: Table,
-) {
-    println!("\nDuplicate Set {} of {}\n", dup_index + 1, dup_size);
-    table.printstd();
-    let files_to_delete = scan_group_instruction().unwrap_or_default();
-    let parsed_file_indices = files_to_delete
-        .trim()
-        .split(',')
-        .filter(|element| !element.is_empty())
-        .map(|index| index.parse::<usize>().unwrap_or_default())
-        .collect::<Vec<usize>>();
-
-    if parsed_file_indices
-        .clone()
-        .into_iter()
-        .any(|index| index > (duplicates.len() - 1))
-    {
-        println!("{}", "Err: File Index Out of Bounds!".red());
-        return process_group_action(duplicates, dup_index, dup_size, table);
+        Ok(())
    }

-    print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
+    pub fn scan_group_confirmation() -> Result<bool> {
+        print!("\nconfirm? [y/N]: ");
+        std::io::stdout().flush()?;
+        let mut user_input = String::new();
+        io::stdin().read_line(&mut user_input)?;

-    if parsed_file_indices.is_empty() {
-        return;
-    }
-
-    let files_to_delete = parsed_file_indices
-        .into_iter()
-        .map(|index| duplicates[index].clone());
-
-    println!("\n{}", "The following files will be deleted:".red());
-    files_to_delete
-        .clone()
-        .enumerate()
-        .for_each(|(index, file)| {
-            println!("{}: {}", index.to_string().blue(), file.path.display());
-        });
-
-    match scan_group_confirmation().unwrap() {
-        true => {
-            files_to_delete.into_iter().for_each(|file| {
-                match std::fs::remove_file(file.path.clone()) {
-                    Ok(_) => println!("{}: {}", "DELETED".green(), file.path.display()),
-                    Err(_) => println!("{}: {}", "FAILED".red(), file.path.display()),
-                }
-            });
+        match user_input.trim() {
+            "Y" | "y" => Ok(true),
+            _ => Ok(false),
+        }
+    }
+
+    pub fn scan_group_instruction() -> Result<String> {
+        println!("\nEnter the indices of the files you want to delete.");
+        println!("You can enter multiple files using commas to seperate file indices.");
+        println!("example: 1,2");
+        print!("\n> ");
+        std::io::stdout().flush()?;
+        let mut user_input = String::new();
+        io::stdin().read_line(&mut user_input)?;
+
+        Ok(user_input)
+    }
+
+    pub fn process_group_action(
+        duplicates: &Vec<FileInfo>,
+        dup_index: usize,
+        dup_size: usize,
+        table: Table,
+    ) {
+        println!("\nDuplicate Set {} of {}\n", dup_index + 1, dup_size);
+        table.printstd();
+        let files_to_delete = Self::scan_group_instruction().unwrap_or_default();
+        let parsed_file_indices = files_to_delete
+            .trim()
+            .split(',')
+            .filter(|element| !element.is_empty())
+            .map(|index| index.parse::<usize>().unwrap_or_default())
+            .collect::<Vec<usize>>();
+
+        if parsed_file_indices
+            .clone()
+            .into_iter()
+            .any(|index| index > (duplicates.len() - 1))
+        {
+            println!("Err: File Index Out of Bounds!");
+            return Self::process_group_action(duplicates, dup_index, dup_size, table);
+        }
+
+        print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
+
+        if parsed_file_indices.is_empty() {
+            return;
+        }
+
+        let files_to_delete = parsed_file_indices
+            .into_iter()
+            .map(|index| duplicates[index].clone());
+
+        println!("\nThe following files will be deleted:");
+        files_to_delete
+            .clone()
+            .enumerate()
+            .for_each(|(index, file)| {
+                println!("{}: {}", index, file.path.display());
+            });
+
+        match Self::scan_group_confirmation().unwrap() {
+            true => {
+                files_to_delete.into_iter().for_each(|file| {
+                    match std::fs::remove_file(file.path.clone()) {
+                        Ok(_) => println!("DELETED: {}", file.path.display()),
+                        Err(_) => println!("FAILED: {}", file.path.display()),
+                    }
+                });
+            }
+            false => println!("\nCancelled Delete Operation."),
        }
-        false => println!("{}", "\nCancelled Delete Operation.".red()),
    }
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,24 +4,32 @@ mod interactive;
 mod params;
 mod processor;
 mod scanner;
+mod server;

+use self::{formatter::Formatter, interactive::Interactive, server::Server};
 use anyhow::Result;
 use clap::Parser;
-use formatter::Formatter;
 use params::Params;
-use processor::Processor;
-use scanner::Scanner;
+use std::sync::atomic::Ordering;

 fn main() -> Result<()> {
    let app_args = Params::parse();
-    let scan_results = Scanner::build(&app_args)?.scan()?;
-    let processor = Processor::new(scan_results);
-    let results = processor.sizewise()?.hashwise()?;
+    let server = Server::new(app_args.clone());
+
+    server.start()?;

    match app_args.interactive {
-        false => { Formatter::print(results.files, &app_args)?; }
-        true => { interactive::init(results.files, &app_args)?; }
-    }
+        false => {
+            Formatter::print(
+                server.hw_duplicate_set,
+                server.max_file_path_len.load(Ordering::Acquire),
+                &app_args,
+            );
+        }
+        true => {
+            Interactive::init(server.hw_duplicate_set, &app_args)?;
+        }
+    };

    Ok(())
 }
--- a/src/params.rs
+++ b/src/params.rs
@@ -2,10 +2,14 @@ use std::{fs, path::PathBuf};

 use anyhow::Result;
 use clap::{Parser, ValueHint};
+use std::collections::HashSet;

-#[derive(Parser, Debug, Clone)]
+#[derive(Parser, Debug, Default, Clone)]
 #[command(author, version, about, long_about = None)]
 pub struct Params {
+    /// Exclude Filetypes [default = none]
+    #[arg(short = 'T', long)]
+    pub exclude_types: Option<String>,
    /// Filetypes to deduplicate [default = all]
    #[arg(short, long)]
    pub types: Option<String>,
@@ -16,17 +20,23 @@ pub struct Params {
    #[arg(long, short)]
    pub interactive: bool,
    /// Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T).
-    #[arg(long, short = 's', default_value = "1b")]
+    #[arg(long, short = 'm', default_value = "1b")]
    pub min_size: Option<String>,
    /// Max Depth to scan while looking for duplicates
-    #[arg(long, short = 'd')]
+    #[arg(long, short = 'D')]
    pub max_depth: Option<usize>,
    /// Min Depth to scan while looking for duplicates
-    #[arg(long)]
+    #[arg(long, short = 'd')]
    pub min_depth: Option<usize>,
    /// Follow links while scanning directories
    #[arg(long, short)]
    pub follow_links: bool,
+    /// Guarantees that two files are duplicate (performs a full hash)
+    #[arg(long, short = 's', default_value = "false")]
+    pub strict: bool,
+    /// Show Progress spinners & metrics
+    #[arg(long, short = 'p', default_value = "false")]
+    pub progress: bool,
 }

 impl Params {
@@ -47,7 +57,47 @@ impl Params {
        Ok(dir)
    }

+    pub fn types_intersection(itypes: &str, xtypes: &str) -> String {
+        let iset = itypes
+            .split(",")
+            .map(String::from)
+            .collect::<HashSet<String>>();
+        let xset = xtypes
+            .split(",")
+            .map(String::from)
+            .collect::<HashSet<String>>();
+
+        iset.difference(&xset)
+            .cloned()
+            .collect::<Vec<String>>()
+            .join(",")
+    }
+
    pub fn get_types(&self) -> Option<String> {
-        self.types.clone()
+        match &self.types {
+            Some(itypes) => match &self.exclude_types {
+                Some(xtypes) => Some(Self::types_intersection(itypes, xtypes)),
+                None => Some(itypes.to_string()),
+            },
+            None => self.exclude_types.as_ref().map(|xtypes| xtypes.to_string()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mixing_include_and_exclude_types_works_as_expected() {
+        let params = Params {
+            types: Some(String::from("js,xml,ts,pdf,tiff")),
+            exclude_types: Some(String::from("js,ts,xml")),
+            ..Default::default()
+        };
+
+        assert!(params
+            .get_types()
+            .is_some_and(|x| x == "pdf,tiff" || x == "tiff,pdf"))
    }
 }
--- a/src/processor.rs
+++ b/src/processor.rs
@@ -1,107 +1,381 @@
 use anyhow::Result;
 use dashmap::DashMap;
-use indicatif::{ParallelProgressIterator, ProgressBar, ProgressStyle, ProgressFinish};
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use rayon::iter::IntoParallelRefMutIterator;
 use rayon::prelude::{IntoParallelIterator, ParallelIterator};
-use std::{time::Duration, borrow::Cow};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, TryLockError, TryLockResult};
+use std::time::Duration;

 use crate::fileinfo::FileInfo;
+use crate::params::Params;

-#[derive(Debug, Clone)]
-pub enum State {
-    Initial,
-    SizeWise,
-    HashWise,
-}
-
-#[derive(Debug, Clone)]
-pub struct Processor {
-    pub files: Vec<FileInfo>,
-    pub state: State,
-}
+pub struct Processor {}

 impl Processor {
-    pub fn new(files: Vec<FileInfo>) -> Self {
-        Self {
-            files,
-            state: State::Initial,
+    pub fn hashwise(
+        app_args: Arc<Params>,
+        sw_store: Arc<DashMap<u64, Vec<FileInfo>>>,
+        hw_store: Arc<DashMap<u128, Vec<FileInfo>>>,
+        progress_bar_box: Arc<MultiProgress>,
+        max_file_size: Arc<AtomicU64>,
+        seed: i64,
+        sw_sorting_finished: Arc<AtomicBool>,
+    ) -> Result<()> {
+        let progress_bar = match app_args.progress {
+            true => progress_bar_box.add(ProgressBar::new_spinner()),
+            false => ProgressBar::hidden(),
+        };
+
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("files grouped by hash.");
+
+        loop {
+            let keys: Vec<u64> = sw_store
+                .clone()
+                .iter()
+                .filter(|i| !i.value().iter().all(|x| x.is_sw_processed()))
+                .filter(|i| i.value().len() > 1)
+                .map(|i| *i.key())
+                .collect();
+
+            if keys.is_empty() {
+                match sw_sorting_finished.load(std::sync::atomic::Ordering::Relaxed) {
+                    true => {
+                        progress_bar.finish_with_message("files grouped by hash.");
+                        break Ok(());
+                    }
+                    false => continue,
+                }
+            } else {
+                keys.into_par_iter().for_each(|key| {
+                    let mut group: Vec<FileInfo> = sw_store.get(&key).unwrap().to_vec();
+                    if group.len() > 1 {
+                        group.par_iter_mut().for_each(|file| {
+                            progress_bar.inc(1);
+                            file.sw_processed();
+
+                            let fhash = match app_args.strict {
+                                true => file.hash(seed).expect("hashing file failed."),
+                                false => file.initpages_hash(seed).expect("hashing file failed."),
+                            };
+
+                            Self::compare_and_update_max_path_len(
+                                max_file_size.clone(),
+                                file.path.to_string_lossy().len() as u64,
+                            );
+
+                            hw_store
+                                .entry(fhash)
+                                .and_modify(|fileset| fileset.push(file.clone()))
+                                .or_insert_with(|| vec![file.clone()]);
+                        });
+                    };
+                });
+            }
        }
    }

-    pub fn hashwise(&self) -> Result<Self> {
-        if self.files.is_empty() {
-            return Ok(self.clone());
+    pub fn compare_and_update_max_path_len(current: Arc<AtomicU64>, next: u64) {
+        if current.load(Ordering::Relaxed) < next {
+            current.store(next, Ordering::Release);
        }
-
-        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")?;
-        let progress_bar = ProgressBar::new(self.files.len() as u64);
-        progress_bar.set_style(progress_style);
-        progress_bar.enable_steady_tick(Duration::from_millis(50));
-        progress_bar.set_message("indexing file hashes");
-
-        let duplicates_table: DashMap<String, Vec<FileInfo>> = DashMap::new();
-        self.files
-            .clone()
-            .into_par_iter()
-            .progress_with(progress_bar)
-            .with_finish(ProgressFinish::WithMessage(Cow::from("indexed files hashes")))
-            .map(|file| file.hash())
-            .filter_map(Result::ok)
-            .for_each(|file| {
-                duplicates_table
-                    .entry(file.hash.clone().unwrap_or_default())
-                    .and_modify(|fileset| fileset.push(file.clone()))
-                    .or_insert_with(|| vec![file]);
-            });
-
-        let files = duplicates_table
-            .into_read_only()
-            .values()
-            .cloned()
-            .filter(|subfiles| subfiles.len() > 1)
-            .flatten()
-            .collect::<Vec<FileInfo>>();
-
-        Ok(Self {
-            files,
-            state: State::HashWise,
-        })
    }

-    pub fn sizewise(&self) -> Result<Self> {
-        if self.files.is_empty() {
-            return Ok(self.clone());
-        }
+    pub fn sizewise(
+        app_args: Arc<Params>,
+        scanner_finished: Arc<AtomicBool>,
+        store: Arc<DashMap<u64, Vec<FileInfo>>>,
+        files: Arc<Mutex<Vec<FileInfo>>>,
+        progress_bar_box: Arc<MultiProgress>,
+    ) -> Result<()> {
+        let progress_bar = match app_args.progress {
+            true => progress_bar_box.add(ProgressBar::new_spinner()),
+            false => ProgressBar::hidden(),
+        };

-        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")?;
-        let progress_bar = ProgressBar::new(self.files.len() as u64);
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
        progress_bar.set_style(progress_style);
        progress_bar.enable_steady_tick(Duration::from_millis(50));
-        progress_bar.set_message("indexing file sizes");
+        progress_bar.set_message("files grouped by size");

-        let duplicates_table: DashMap<u64, Vec<FileInfo>> = DashMap::new();
-        self.files
-            .clone()
-            .into_par_iter()
-            .progress_with(progress_bar)
-            .with_finish(ProgressFinish::WithMessage(Cow::from("indexed files sizes")))
-            .for_each(|file| {
-                duplicates_table
-                    .entry(file.size)
-                    .and_modify(|fileset| fileset.push(file.clone()))
-                    .or_insert_with(|| vec![file]);
-            });
+        loop {
+            let fileopt: Option<FileInfo> = {
+                match files.try_lock() {
+                    Ok(mut flist) => flist.pop(),
+                    TryLockResult::Err(TryLockError::WouldBlock) => None,
+                    _ => None,
+                }
+            };

-        let files = duplicates_table
-            .into_read_only()
-            .values()
-            .cloned()
-            .filter(|subfiles| subfiles.len() > 1)
-            .flatten()
-            .collect::<Vec<FileInfo>>();
-
-        Ok(Self {
-            files,
-            state: State::SizeWise,
-        })
+            match fileopt {
+                Some(file) => {
+                    progress_bar.inc(1);
+                    store
+                        .entry(file.size)
+                        .and_modify(|fileset| fileset.push(file.clone()))
+                        .or_insert_with(|| vec![file]);
+                    continue;
+                }
+                None => match scanner_finished.load(std::sync::atomic::Ordering::Relaxed) {
+                    true => {
+                        progress_bar.finish_with_message("files grouped by size");
+                        break Ok(());
+                    }
+                    false => continue,
+                },
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+    use dashmap::DashMap;
+    use indicatif::MultiProgress;
+    use rand::Rng;
+    use std::fs::File;
+    use std::io::Write;
+    use std::sync::atomic::{AtomicBool, AtomicU64};
+    use std::sync::{Arc, Mutex};
+    use tempfile::TempDir;
+
+    use crate::{fileinfo::FileInfo, params::Params};
+
+    use super::Processor;
+
+    fn generate_bytes(size: usize) -> Vec<u8> {
+        let mut rng = rand::rng();
+        (0..size).map(|_| rng.random::<u8>()).collect::<Vec<u8>>()
+    }
+
+    #[test]
+    fn hashwise_sorting_two_files_with_identical_init_pages_only_strict_mode() -> Result<()> {
+        let root = TempDir::new()?;
+        let content = generate_bytes(16384);
+
+        let mut content_x = content.clone();
+        let mut content_y = content.clone();
+
+        content_x.extend(generate_bytes(1720320));
+        content_y.extend(generate_bytes(1720320));
+
+        let files = [
+            (root.path().join("fileone.bin"), content_x),
+            (root.path().join("filetwo.bin"), content_y),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let dupstore = Arc::new(DashMap::new());
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let hw_dupstore = Arc::new(DashMap::new());
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        let args = Params {
+            strict: true,
+            ..Default::default()
+        };
+
+        Processor::hashwise(
+            Arc::new(args),
+            dupstore.clone(),
+            hw_dupstore.clone(),
+            Arc::new(MultiProgress::new()),
+            Arc::new(AtomicU64::new(32)),
+            300,
+            Arc::new(AtomicBool::new(true)),
+        )?;
+
+        assert_eq!(hw_dupstore.len(), 2);
+
+        Ok(())
+    }
+
+    #[test]
+    fn hashwise_sorting_two_files_with_identical_init_pages_only_fast_mode() -> Result<()> {
+        let root = TempDir::new()?;
+        let content = generate_bytes(16384);
+
+        let mut content_x = content.clone();
+        let mut content_y = content.clone();
+
+        content_x.extend(generate_bytes(1720320));
+        content_y.extend(generate_bytes(1720320));
+
+        let files = [
+            (root.path().join("fileone.bin"), content_x),
+            (root.path().join("filetwo.bin"), content_y),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let dupstore = Arc::new(DashMap::new());
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let hw_dupstore = Arc::new(DashMap::new());
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        Processor::hashwise(
+            Arc::new(Params::default()),
+            dupstore.clone(),
+            hw_dupstore.clone(),
+            Arc::new(MultiProgress::new()),
+            Arc::new(AtomicU64::new(32)),
+            300,
+            Arc::new(AtomicBool::new(true)),
+        )?;
+
+        assert_eq!(hw_dupstore.len(), 1);
+
+        Ok(())
+    }
+
+    #[test]
+    fn hashwise_sorting_two_files_with_identical_data() -> Result<()> {
+        let root = TempDir::new()?;
+        let content = generate_bytes(282624);
+        let files = [
+            (root.path().join("fileone.bin"), content.clone()),
+            (root.path().join("filetwo.bin"), content.clone()),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let dupstore = Arc::new(DashMap::new());
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let hw_dupstore = Arc::new(DashMap::new());
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        Processor::hashwise(
+            Arc::new(Params::default()),
+            dupstore.clone(),
+            hw_dupstore.clone(),
+            Arc::new(MultiProgress::new()),
+            Arc::new(AtomicU64::new(32)),
+            300,
+            Arc::new(AtomicBool::new(true)),
+        )?;
+
+        assert_eq!(hw_dupstore.len(), 1);
+
+        Ok(())
+    }
+
+    #[test]
+    fn sizewise_sorting_two_files_of_different_sizes() -> Result<()> {
+        let root = TempDir::new()?;
+        let files = [
+            (root.path().join("fileone.bin"), generate_bytes(282624)),
+            (root.path().join("filetwo.bin"), generate_bytes(1720320)),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let dupstore = Arc::new(DashMap::new());
+
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        assert_eq!(dupstore.len(), 2);
+
+        Ok(())
+    }
+
+    #[test]
+    fn sizewise_sorting_two_files_of_same_size() -> Result<()> {
+        let root = TempDir::new()?;
+        let files = [
+            (root.path().join("fileone.bin"), generate_bytes(282624)),
+            (root.path().join("filetwo.bin"), generate_bytes(282624)),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let dupstore = Arc::new(DashMap::new());
+
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        assert_eq!(dupstore.len(), 1);
+
+        Ok(())
    }
 }
--- a/src/scanner.rs
+++ b/src/scanner.rs
@@ -1,118 +1,39 @@
-#![allow(unused)]
 use crate::{fileinfo::FileInfo, params::Params};
 use anyhow::Result;
-use indicatif::{ProgressBar, ProgressStyle};
-use std::{fs, path::PathBuf, time::Duration};
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use std::sync::{Arc, Mutex};
+use std::{path::Path, time::Duration};

 use globwalk::{GlobWalker, GlobWalkerBuilder};

-#[derive(Debug, Clone)]
 pub struct Scanner {
-    pub directory: Option<PathBuf>,
+    pub directory: Box<Path>,
    pub filetypes: Option<String>,
    pub min_depth: Option<usize>,
    pub max_depth: Option<usize>,
    pub min_size: Option<u64>,
    pub follow_links: bool,
+    pub progress: bool,
 }

 impl Scanner {
-    pub fn new() -> Self {
-        Self {
-            directory: None,
-            filetypes: None,
-            min_depth: None,
-            max_depth: None,
-            min_size: None,
-            follow_links: true,
-        }
-    }
-
-    pub fn build(app_args: &Params) -> Result<Self> {
-        let scan_directory = app_args.get_directory()?;
-        Ok(Scanner::new())
-            .map(|scanner| scanner.directory(scan_directory))
-            .map(|scanner| match app_args.get_min_size() {
-                Some(min_size) => scanner.min_size(min_size),
-                None => scanner,
-            })
-            .map(|scanner| match app_args.get_types() {
-                Some(ftypes) => scanner.filetypes(ftypes),
-                None => scanner,
-            })
-            .map(|scanner| match app_args.min_depth {
-                Some(min_depth) => scanner.min_depth(min_depth),
-                None => scanner,
-            })
-            .map(|scanner| match app_args.max_depth {
-                Some(max_depth) => scanner.max_depth(max_depth),
-                None => scanner,
-            })
-    }
-
-    pub fn min_size(&self, min_size: u64) -> Self {
-        Self {
-            min_size: Some(min_size),
-            ..self.clone()
-        }
-    }
-
-    pub fn min_depth(&self, min_depth: usize) -> Self {
-        Self {
-            min_depth: Some(min_depth),
-            ..self.clone()
-        }
-    }
-
-    pub fn max_depth(&self, max_depth: usize) -> Self {
-        Self {
-            max_depth: Some(max_depth),
-            ..self.clone()
-        }
-    }
-
-    pub fn directory(&self, dir: PathBuf) -> Self {
-        Self {
-            directory: Some(dir),
-            ..self.clone()
-        }
-    }
-
-    pub fn filetypes(&self, patterns: String) -> Self {
-        Self {
-            filetypes: Some(patterns),
-            ..self.clone()
-        }
-    }
-
-    pub fn ignore_links(&self) -> Self {
-        Self {
-            follow_links: false,
-            ..self.clone()
-        }
-    }
-
-    pub fn follow_links(&self) -> Self {
-        Self {
-            follow_links: true,
-            ..self.clone()
-        }
-    }
-
-    fn scan_patterns(&self) -> Result<String> {
-        Ok(match self.filetypes.clone() {
-            Some(ftypes) => format!("**/*{{{ftypes}}}"),
-            None => "**/*".to_string(),
+    pub fn new(app_args: Arc<Params>) -> Result<Self> {
+        Ok(Self {
+            directory: app_args.get_directory()?.into_boxed_path(),
+            filetypes: app_args.get_types(),
+            min_depth: app_args.min_depth,
+            max_depth: app_args.max_depth,
+            min_size: app_args.get_min_size(),
+            follow_links: app_args.follow_links,
+            progress: app_args.progress,
        })
    }

-    fn scan_dir(&self) -> Result<PathBuf> {
-        let scan_dir = match self.directory.clone() {
-            Some(path) => path,
-            None => std::env::current_dir()?,
-        };
-
-        Ok(fs::canonicalize(scan_dir)?)
+    fn scan_patterns(&self) -> Result<String> {
+        Ok(match &self.filetypes {
+            Some(ftypes) => format!("**/*{{{ftypes}}}"),
+            None => "**/*".to_string(),
+        })
    }

    fn attach_link_opts(&self, walker: GlobWalkerBuilder) -> Result<GlobWalkerBuilder> {
@@ -134,7 +55,7 @@ impl Scanner {
    }
    fn build_walker(&self) -> Result<GlobWalker> {
        let walker = Ok(GlobWalkerBuilder::from_patterns(
-            self.scan_dir()?,
+            self.directory.clone(),
            &[self.scan_patterns()?],
        ))
        .and_then(|walker| self.attach_walker_min_depth(walker))
@@ -144,30 +65,36 @@ impl Scanner {
        Ok(walker.build()?)
    }

-    pub fn scan(&self) -> Result<Vec<FileInfo>> {
+    pub fn scan(
+        &self,
+        files: Arc<Mutex<Vec<FileInfo>>>,
+        progress_bar_box: Arc<MultiProgress>,
+    ) -> Result<()> {
+        let progress_bar = match self.progress {
+            true => progress_bar_box.add(ProgressBar::new_spinner()),
+            false => ProgressBar::hidden(),
+        };
+
        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
-        let progress_bar = ProgressBar::new_spinner();
        progress_bar.set_style(progress_style);
        progress_bar.enable_steady_tick(Duration::from_millis(50));
        progress_bar.set_message("paths mapped");
        let min_size = self.min_size.unwrap_or_default();

-        let results = self
-            .build_walker()?
+        self.build_walker()?
            .filter_map(Result::ok)
            .map(|entity| entity.into_path())
-            .map(|path| {
-                progress_bar.inc(1);
-                path
-            })
+            .inspect(|_path| progress_bar.inc(1))
            .filter(|path| path.is_file())
            .map(FileInfo::new)
            .filter_map(Result::ok)
            .filter(|file| file.size > min_size)
-            .collect::<Vec<FileInfo>>();
+            .for_each(|file| {
+                let mut flock = files.lock().unwrap();
+                flock.push(file);
+            });

        progress_bar.finish_with_message("paths mapped");
-
-        Ok(results)
+        Ok(())
    }
 }
--- a/src/server.rs
+++ b/src/server.rs
@@ -0,0 +1,109 @@
+use std::sync::atomic::{AtomicBool, AtomicU64};
+use std::sync::{Arc, Mutex};
+
+use crate::processor::Processor;
+use crate::scanner::Scanner;
+use anyhow::Result;
+use dashmap::DashMap;
+use indicatif::{MultiProgress, ProgressDrawTarget};
+use rand::Rng;
+use threadpool::ThreadPool;
+
+use crate::fileinfo::FileInfo;
+use crate::params::Params;
+
+pub struct Server {
+    filequeue: Arc<Mutex<Vec<FileInfo>>>,
+    sw_duplicate_set: Arc<DashMap<u64, Vec<FileInfo>>>,
+    pub hw_duplicate_set: Arc<DashMap<u128, Vec<FileInfo>>>,
+    threadpool: ThreadPool,
+    app_args: Arc<Params>,
+    pub max_file_path_len: Arc<AtomicU64>,
+}
+
+impl Server {
+    pub fn new(opts: Params) -> Self {
+        Self {
+            filequeue: Arc::new(Mutex::new(Vec::new())),
+            sw_duplicate_set: Arc::new(DashMap::new()),
+            hw_duplicate_set: Arc::new(DashMap::new()),
+            threadpool: ThreadPool::new(4),
+            app_args: Arc::new(opts),
+            max_file_path_len: Arc::new(AtomicU64::new(0)),
+        }
+    }
+
+    pub fn start(&self) -> Result<()> {
+        let progbarbox = Arc::new(MultiProgress::new());
+        let mut rng = rand::rng();
+        let seed: i64 = rng.random();
+
+        if !self.app_args.progress {
+            progbarbox.set_draw_target(ProgressDrawTarget::hidden());
+        }
+
+        let app_args_clone_for_sc = self.app_args.clone();
+        let app_args_clone_for_sw = self.app_args.clone();
+        let app_args_clone_for_hw = self.app_args.clone();
+        let file_queue_clone_sc = self.filequeue.clone();
+        let file_queue_clone_pr = self.filequeue.clone();
+        let scanner_finished = Arc::new(AtomicBool::new(false));
+        let sw_sort_finished = Arc::new(AtomicBool::new(false));
+
+        let sfin_sc_tr_cl = scanner_finished.clone();
+        let sfin_pr_tr_cl = scanner_finished.clone();
+
+        let swfin_pr_tr_sw = sw_sort_finished.clone();
+        let swfin_pr_tr_hw = sw_sort_finished.clone();
+
+        let store_dupl_sw_for_sw = self.sw_duplicate_set.clone();
+        let store_dupl_sw_for_hw = self.sw_duplicate_set.clone();
+        let store_dupl_hw = self.hw_duplicate_set.clone();
+        let max_file_path_len_clone = self.max_file_path_len.clone();
+
+        let progbarbox_sc_clone = progbarbox.clone();
+        let progbarbox_pr_clone_for_sw = progbarbox.clone();
+        let progbarbox_pr_clone_for_hw = progbarbox.clone();
+
+        self.threadpool.execute(move || {
+            Scanner::new(app_args_clone_for_sc)
+                .expect("unable to initialize scanner.")
+                .scan(file_queue_clone_sc, progbarbox_sc_clone)
+                .expect("scanner failed.");
+
+            sfin_sc_tr_cl.store(true, std::sync::atomic::Ordering::Relaxed);
+        });
+
+        self.threadpool.execute(move || {
+            Processor::sizewise(
+                app_args_clone_for_sw,
+                sfin_pr_tr_cl,
+                store_dupl_sw_for_sw,
+                file_queue_clone_pr,
+                progbarbox_pr_clone_for_sw,
+            )
+            .expect("sizewise scanner failed.");
+
+            swfin_pr_tr_sw.store(true, std::sync::atomic::Ordering::Relaxed);
+        });
+
+        self.threadpool.execute(move || {
+            Processor::hashwise(
+                app_args_clone_for_hw,
+                store_dupl_sw_for_hw,
+                store_dupl_hw,
+                progbarbox_pr_clone_for_hw,
+                max_file_path_len_clone,
+                seed,
+                swfin_pr_tr_hw,
+            )
+            .expect("sizewise scanner failed.");
+        });
+
+        progbarbox.clear()?;
+
+        self.threadpool.join();
+
+        Ok(())
+    }
+}
Author	SHA1	Message	Date
sreedevk	d06fe93171	fix pipeline breaks	2025-07-19 13:41:52 +00:00
sreedevk	6a24ca5ecf	updated github release pipeline	2025-07-19 12:15:42 +00:00
sreedevk	6f23a51a53	created a automatic release ci pipeline	2025-07-19 12:00:25 +00:00
sreedevk	4894d1b4db	minor ui improvements	2025-07-19 11:43:26 +00:00
sreedevk	c0286b17cc	fix: hash collision edge case	2025-07-19 11:33:52 +00:00
sreedevk	e78dfc4211	updated dependencies	2025-07-19 02:01:15 +00:00
sreedevk	66f49a9aee	benchmarks updated	2025-07-19 01:35:24 +00:00
sreedevk	711eb36fb9	output formatting and printing performance improvements	2025-07-19 01:26:46 +00:00
sreedevk	130a8f99ba	partial hash page count increased	2025-07-18 11:25:37 +00:00
sreedevk	d97af6b8f6	improved parallelization + updated benchmarks	2025-07-17 00:31:40 +00:00
sreedevk	90198502a3	added exclude file types. updated documentation to include exclude file types.	2025-07-14 12:56:07 +00:00
sreedevk	e1b81b9981	page hash aggregation method improvement	2025-07-14 01:02:14 +00:00
sreedevk	48e7c62036	added planned features	2025-07-14 00:23:16 +00:00
Sreedev Kodichath	58e33cc8da	v0.3 (#61 ) - [x] parallelization - [x] (scanning) + (processing sw & processing hw & formatting & printing) - [x] reduce cloning values on the heap - [x] add a partial hashing mode (--strict) - [x] add unit tests - [x] add silent mode - [x] update documentation - [x] remove color output - [x] progress bar improvements - [x] use progress bar groups - [x] remove broken json rendering - [x] add benchmarks	2025-07-13 19:03:14 -04:00
sreedevk	f9e86f8522	performance improvements	2025-07-12 00:24:25 +00:00
sreedev	b4bf5d4fb3	docs updated	2024-07-05 04:34:12 +00:00
Sreedev Kodichath	028b868ea9	version 0.2.2 (#59 ) * replaced fxhash with gxhash	2024-07-04 23:23:01 -04:00
Sreedev Kodichath	a56d194ee3	Merge pull request #56 from sreedevk/feature/add-json-output Version 0.2.1	2023-11-14 18:38:50 -05:00
sreedev	080cd791dc	removed early return	2023-11-14 18:37:48 -05:00
sreedev	b16236763c	updated readme + version number	2023-11-14 18:36:27 -05:00
sreedev	3e407f69c8	added json output for further processing using other tools	2023-11-14 18:33:40 -05:00
Sreedev Kodichath	7d386c9420	Merge pull request #54 from sreedevk/distribution-improvements Improve Distribution Methods & Create Compiled Binaries for More Platforms	2023-08-10 19:54:29 -04:00
sreedev	0dc681d4e7	added release yml	2023-08-10 19:51:57 -04:00
sreedev	442cb4b519	added cargo dist options	2023-08-10 13:05:29 -04:00
sreedev	8463e72f2d	removed debug information from distrbution & release profiles to reduce binary size	2023-08-10 12:59:07 -04:00
sreedev	05c95bb67a	added roadmap to readme	2023-08-02 09:41:15 -04:00
				`@@ -0,0 +1 @@`
				# tasks are contained in the `rakelib` directory