fd File Finding Expert knowledge for using fd as a fast, user-friendly alternative to find with smart defaults and powerful filtering. Core Expertise fd Advantages Fast parallel execution (written in Rust) Colorized output by default Respects .gitignore automatically Smart case-insensitive search Simpler syntax than find Regular expression support Basic Usage Simple File Search

Find all files named config

fd config

Find files with extension

fd -e rs

All Rust files

fd -e md

All Markdown files

fd -e js -e ts

JavaScript and TypeScript

Case-sensitive search

fd -s Config

Only exact case match

Pattern Matching

Regex patterns

fd '^test_.*.py$'

Python test files

fd '.config$'

Files ending in .config

fd '^[A-Z]'

Files starting with uppercase

Glob patterns

fd '*.lua'

All Lua files

fd 'test-*.js'

test-*.js files

Advanced Filtering Type Filtering

Search only files

fd -t f pattern

Files only

fd -t d pattern

Directories only

fd -t l pattern

Symlinks only

fd -t x pattern

Executable files

Multiple types

fd -t f -t l pattern

Files and symlinks

Depth Control

Limit search depth

fd -d 1 pattern

Only current directory

fd -d 3 pattern

Max 3 levels deep

fd --max-depth 2 pattern

Alternative syntax

Minimum depth

fd --min-depth 2 pattern

Skip current directory

Hidden and Ignored Files

Include hidden files

fd -H pattern

Include hidden files (starting with .)

Include ignored files

fd -I pattern

Include .gitignore'd files

fd -u pattern

Unrestricted: hidden + ignored

Show all files

fd -H -I pattern

Show everything

Size Filtering

File size filters

fd --size +10m

Files larger than 10 MB

fd --size -1k

Files smaller than 1 KB

fd --size +100k --size -10m

Between 100 KB and 10 MB

Modification Time

Files modified recently

fd --changed-within 1d

Last 24 hours

fd --changed-within 2w

Last 2 weeks

fd --changed-within 3m

Last 3 months

Files modified before

fd --changed-before 1y

Older than 1 year

Execution and Processing Execute Commands

Execute command for each result

fd -e jpg -x convert { } { . } .png

Convert all JPG to PNG

Parallel execution

fd -e rs -x rustfmt

Format all Rust files

Execute with multiple results

fd -e md -X wc -l

Word count on all Markdown files

Output Formatting

Custom output format using placeholders

fd -e tf --format '{//}'

Parent directory of each file

fd -e rs --format '{/}'

Filename without directory

fd -e md --format '{.}'

Path without extension

Placeholders:

{} - Full path (default)

{/} - Basename (filename only)

{//} - Parent directory

{.} - Path without extension

{/.} - Basename without extension

Integration with Other Tools

Prefer fd's native execution over xargs when possible:

fd -e log -x rm

Delete all log files (native)

fd -e rs -X wc -l

Count lines in Rust files (batch)

Use with rg for powerful search

fd -e py -x rg "import numpy" { }

Find numpy imports in Python files

Open files in editor

fd -e md -X nvim

Open all Markdown in Neovim (batch)

When xargs IS useful: complex pipelines or non-fd inputs

cat filelist.txt | xargs rg "TODO"

Process file from external list

Common Patterns Development Workflows

Find test files

fd -e test.js -e spec.js

JavaScript tests

fd '^test_.*.py$'

Python tests

fd '_test.go$'

Go tests

Find configuration files

fd -g '*.config.js'

Config files

fd -g '.env*'

Environment files

fd -g '*rc' -H

RC files (include hidden)

Find source files

fd -e rs -e toml -t f

Rust project files

fd -e py --exclude pycache

Python excluding cache

fd -e ts -e tsx src/

TypeScript in src/

Cleanup Operations

Find and remove

fd -e pyc -x rm

Remove Python bytecode

fd node_modules -t d -x rm -rf

Remove node_modules

fd -g '*.log' --changed-before 30d -X rm

Remove old logs

Find large files

fd --size +100m -t f

Files over 100 MB

fd --size +1g -t f -x du -h

Size of files over 1 GB

Path-Based Search

Search in specific directories

fd pattern src/

Only in src/

fd pattern src/ tests/

Multiple directories

Exclude paths

fd -e rs -E target/

Exclude target directory

fd -e js -E node_modules -E dist

Exclude multiple paths

Full path matching

fd -p src/components/.* \ .tsx$

Match full path

Find Directories Containing Specific Files

Find all directories with Terraform configs

fd -t f 'main.tf$' --format '{//}'

Find all directories with package.json

fd -t f '^package.json$' --format '{//}'

Find Go module directories

fd -t f '^go.mod$' --format '{//}'

Find Python project roots (with pyproject.toml)

fd -t f '^pyproject.toml$' --format '{//}'

Find Cargo.toml directories (Rust projects)

fd -t f '^Cargo.toml$' --format '{//}' Note: Use --format '{//}' instead of piping to xargs - it's faster and simpler. Best Practices When to Use fd Finding files by name or pattern Searching with gitignore awareness Fast directory traversal Type-specific searches Time-based file queries When to Use find Instead Complex boolean logic POSIX compatibility required Advanced permission checks Non-standard file attributes Performance Tips Use -j 1 for sequential search if order matters Combine with --max-depth to limit scope Use -t f to skip directory processing Leverage gitignore for faster searches in repos Integration with rg

Prefer native execution over xargs

fd -e py -x rg "class.*Test" { }

Find test classes in Python

fd -e rs -x rg "TODO" { }

Find TODOs in Rust files

fd -e md -x rg "# " { }

Find headers in Markdown

Use fd's Built-in Execution

fd can execute directly — no need for xargs

fd -t f 'main.tf$' --format '{//}'

Find dirs containing main.tf

fd -e log -x rm

Delete all .log files

Quick Reference Essential Options Option Purpose Example -e EXT Filter by extension fd -e rs -t TYPE Filter by type (f/d/l/x) fd -t d -d DEPTH Max search depth fd -d 3 -H Include hidden files fd -H .env -I Include ignored files fd -I build -u Unrestricted (no ignore) fd -u pattern -E PATH Exclude path fd -E node_modules -x CMD Execute command fd -e log -x rm -X CMD Batch execute fd -e md -X cat -s Case-sensitive fd -s Config -g GLOB Glob pattern fd -g '*.json' --format FMT Custom output format fd -e tf --format '{//}' Time Units s = seconds m = minutes h = hours d = days w = weeks y = years Size Units b = bytes k = kilobytes m = megabytes g = gigabytes t = terabytes Common Command Patterns

Find recently modified source files

fd -e rs --changed-within 1d

Find large files in current directory

fd -d 1 -t f --size +10m

Find executable scripts

fd -t x -e sh

Find config files including hidden

fd -H -g 'config'

Find and count lines

fd -e py -X wc -l

Find files excluding build artifacts

fd -e js -E dist -E node_modules -E build

Find all Terraform/IaC project directories

fd -t f 'main.tf$' --format '{//}'

Find all Node.js project roots

fd -t f '^package.json$' --format '{//}' This makes fd the preferred tool for fast, intuitive file finding in development workflows.