dirwalk-1.0.0 has been yanked.

dirwalk

Recursive directory walker for Rust. Uses platform-specific APIs to reduce syscall overhead, and comes with built-in filtering, sorting, and parallel walk support.

Each platform uses the fastest available API for directory enumeration:

Platform	API
Windows	`FindFirstFileW` / `FindNextFileW`
macOS	`getattrlistbulk`
Linux	`getdents64` + `statx`
Other Unix	`std::fs::read_dir` + `symlink_metadata`

Feature comparison

Feature	dirwalk	walkdir	jwalk	ignore	fs-walk
Parallel walk	Yes	No	Yes	Yes	No
Gitignore	Yes	No	No	Yes	No
Hidden file filtering	Yes	Yes	Yes	Yes	No
Sorting	Yes	No	No	No	No
Grouping	Yes	No	No	No	No
Tree reconstruction	Yes	No	No	No	No
Glob filtering	Yes	No	No	Yes	No
Size filtering	Yes	No	No	No	No
Symlink loop detection	Yes	Yes	Yes	Yes	No
Max depth	Yes	Yes	Yes	Yes	No
Stats	Yes	No	No	No	No
Serde support	Yes	No	No	No	No

Library usage

use dirwalk::{WalkBuilder, Sort};

let result = WalkBuilder::new("/some/path")
    .max_depth(5)
    .hidden(false)           // exclude hidden files (default)
    .gitignore(true)         // respect .gitignore rules
    .extensions(&["rs", "toml"])
    .sort(Sort::Name)        // natural sort (file2 < file10)
    .dirs_first(true)
    .stats(true)
    .build()
    .unwrap();

for entry in &result.entries {
    println!("{} ({} bytes)", entry.relative_path, entry.size);
}

if let Some(stats) = &result.stats {
    println!("{} files, {} dirs, {} bytes",
        stats.file_count, stats.dir_count, stats.total_size);
}

Single-level scan

use dirwalk::scan_dir;
use std::path::Path;

let entries = scan_dir(Path::new(".")).unwrap();
for entry in &entries {
    println!("{}: {} bytes", entry.name(), entry.size);
}

Filtering

use dirwalk::WalkBuilder;

let result = WalkBuilder::new(".")
    .extensions(&["md", "rs"])    // only these extensions
    .glob("test_*").unwrap()      // glob pattern on name
    .min_size(100)                // minimum file size
    .max_size(1_000_000)          // maximum file size
    .gitignore(true)              // respect .gitignore
    .build()
    .unwrap();

Grouping

use dirwalk::{WalkBuilder, group};

let result = WalkBuilder::new(".").build().unwrap();

let by_ext = group::group_by_extension(&result.entries);
let by_dir = group::group_by_directory(&result.entries);
let by_depth = group::group_by_depth(&result.entries);

Tree reconstruction

use dirwalk::{WalkBuilder, tree};

let result = WalkBuilder::new(".").build().unwrap();
let tree = tree::to_tree(&result.entries);

for node in &tree {
    println!("{} ({} children)", node.entry.name(), node.children.len());
}

CLI (`dirwalk`)

cargo install dirwalk

dirwalk                                    # walk current directory
dirwalk /some/path --max-depth 3
dirwalk . --extensions rs,toml --sort name --dirs-first
dirwalk . --format tree                    # tree view with box-drawing chars
dirwalk . --format json                    # JSON array
dirwalk . --format jsonl                   # one JSON object per line
dirwalk . --format csv                     # CSV with header
dirwalk . --gitignore --hidden --stats     # include hidden, respect gitignore, show stats
dirwalk . --glob "*.test.*" --min-size 100
dirwalk . --group-by extension --format plain

All flags

dirwalk [PATH]                             # defaults to .
    --max-depth <N>
    --hidden                             # include hidden files
    --gitignore                          # respect .gitignore rules
    --follow-links                       # follow symbolic links
    --extensions <ext,ext,...>
    --glob <pattern>
    --min-size <bytes>
    --max-size <bytes>
    --sort <name|modified|size|extension>
    --dirs-first
    --group-by <extension|directory|depth>
    --stats
    --format <plain|tree|json|jsonl|csv>

Benchmarks

Synthetic fixtures with randomized file/directory names. All times are mean wall-clock. Parallel variants use all available cores. Bold values highlight the fastest result for each column, and the ratio tables below each benchmark express every library as a multiplier of dirwalk (parallel) (1.00× = same speed, higher = slower, lower = faster) so you can see the differences at a glance.