Skip to content

fd

What is it?

fd is an open-source, high-performance command-line tool for finding files and directories in a filesystem. It is designed as a modern, human-centric alternative to the traditional find command. Written in Rust, it is optimized for speed through parallelism and provides a more intuitive, concise syntax while defaulting to "smart" behaviors like honoring .gitignore rules.

In the software development ecosystem, fd belongs to the filesystem navigation and automation layer. It serves as a rapid discovery tool for locating project assets, managing build artifacts, and piping file lists into other developer utilities.

Installation (Optional)

!!! note CodeCampus OS includes fd by default. Use the commands below only if you are installing it on a different Linux distribution.

sudo pacman -S fd

sudo apt install fd-find
# Note: On Ubuntu/Debian, the binary is 'fdfind'
# To use 'fd', create an alias or symlink:
mkdir -p ~/.local/bin
ln -s $(which fdfind) ~/.local/bin/fd

sudo dnf install fd-find

Why this tool matters (In Depth)

The traditional find command is notoriously difficult to use, with a syntactic structure that is inconsistent with almost every other Unix utility. To perform a basic search, users must often remember complex flags like -name, -type f, and -print, and deal with the frustration of search results being cluttered by untracked directories like .git or node_modules. fd matters because it lowers the cognitive burden of filesystem interaction.

By default, fd is case-insensitive (unless an uppercase letter is used), uses regular expressions for searching, and automatically ignores hidden files and directories specified in your .gitignore. This means that in 95% of use cases, fd provides exactly the results a developer expects without any extra configuration. Furthermore, its performance on large storage volumes is significantly higher than find due to its multithreaded directory traversal architecture.

For students, fd eliminates the friction of navigating large projects. It allows them to find where a specific file or directory is located using simple keywords, encouraging more efficient project management and reducing the time spent on "administrative" terminal tasks.

How students will actually use it

Students will use fd to manage their project files and automate repetitive tasks:

  • Rapid File Discovery: Finding a file by name without needing to know its exact path (e.g., fd main.c).
  • Extension-Based Filtering: Listing all files of a specific type across their entire workspace (fd -e md for all Markdown files).
  • Targeted Directory Navigation: Locating specific subdirectories, such as finding all "tests" folders in a large codebase.
  • Bulk Command Execution: Using the -x or -X flags to perform an action on every found file, such as formatting all .js files or deleting all .log artifacts.
  • Regex-Powered Search: Finding files that match a complex naming pattern (e.g., fd "v[0-9]+" to find versioned backups).

Professional Insight (Top 1% Knowledge)

The "Top 1%" of productive engineers treat fd as the primary feeding mechanism for their terminal pipelines. A professional habit is using fd in conjunction with fzf. By setting export FZF_DEFAULT_COMMAND='fd --type f', an engineer ensures that their interactive file picker is not only extremely fast but also respects their .gitignore rules automatically.

Another high-level practice is using the --exec-batch (capital -X) flag. Unlike the small -x which runs a command for each file (slow for many files), -X passes all found files as arguments to a single command. This is significantly faster for operations like ls, grep, or code formatters. Senior engineers also know how to use the --changed-within flag to find files that were modified in the last hour, allowing them to rapidly identify which part of a complex system was affected by a recent operation.

The "Top 1%" insight is using fd for dynamic project cleanup. By defining a custom "ignore" file (e.g., ~/.fdignore), an engineer can ensure that their global searches are never cluttered by irrelevant system data or large datasets, even in projects without a .gitignore. Finally, remember that fd is built for interaction. While find is still preferred for critical, platform-agnostic system scripts, fd is the vastly superior choice for your daily, high-speed engineering workflow.