If called with just a single argument like this, fd searches the current directory recursively
for any entries that contain the pattern netfl.
Regular expression search  Copy Section
The search pattern is treated as a regular expression. Here, we search for entries that start
with x and end with rc:

The regular expression syntax used by fd is documented here.
Specifying the root directory  Copy Section
If we want to search a specific directory, it can be given as a second argument to fd:

List all files, recursively  Copy Section
fd can be called with no arguments. This is very useful to get a quick overview of all entries
in the current directory, recursively (similar to ls -R):

If you want to use this functionality to list all files in a given directory, you have to use
a catch-all pattern such as . or ^:

Searching for a particular file extension  Copy Section
Often, we are interested in all files of a particular type. This can be done with the -e (or
--extension) option. Here, we search for all Markdown files in the fd repository:

The -e option can be used in combination with a search pattern:

Searching for a particular file name  Copy Section
 To find files with exactly the provided search pattern, use the -g (or --glob) option:

Hidden and ignored files  Copy Section

By default, fd does not search hidden directories and does not show hidden files in the
search results. To disable this behavior, we can use the -H (or --hidden) option:

If we work in a directory that is a Git repository (or includes Git repositories), fd does not
search folders (and does not show files) that match one of the .gitignore patterns. To disable
this behavior, we can use the -I (or --no-ignore) option:

To really search all files and directories, simply combine the hidden and ignore features to show
everything (-HI) or use -u/--unrestricted.
Matching the full path  Copy Section

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

Command execution  Copy Section
Instead of just showing the search results, you often want to do something with them. fd
provides two ways to execute external commands for each of your search results:
 The -x/--exec option runs an external command for each of the search results* (in parallel).
 The -X/--exec-batch option launches the external command once, with all search results as arguments*.
#### Examples
Recursively find all zip archives and unpack them:

If there are two such files, file1.zip and backup/file2.zip, this would execute
unzip file1.zip and unzip backup/file2.zip. The two unzip processes run in parallel
(if the files are found fast enough).
Find all .h and .cpp files and auto-format them inplace with clang-format -i:

Note how the -i option to clang-format can be passed as a separate argument. This is why
we put the -x option last.
Any positional arguments after -x belong to the command template, not to fd itself. If you
also want to pass a pattern or search path, put -x last:

Find all test_*.py files and open them in your favorite editor:

Note that we use capital -X here to open a single vim instance. If there are two such files,
test_basic.py and lib/test_advanced.py, this will run vim test_basic.py lib/test_advanced.py.
To see details like file permissions, owners, file sizes etc., you can tell fd to show them
by running ls for each result:

This pattern is so useful that fd provides a shortcut. You can use the -l/--list-details
option to execute ls in this way: fd … -l.
The -X option is also useful when combining fd with ripgrep (rg) in order to search within a certain class of files, like all C++ source files:

Convert all .jpg files to .png files:

Here, {} is a placeholder for the search result. {.} is the same, without the file extension.
See below for more details on the placeholder syntax.
The terminal output of commands run from parallel threads using -x will not be interlaced or garbled,
so fd -x can be used to rudimentarily parallelize a task run over many files.
An example of this is calculating the checksum of each individual file within a directory.

#### Placeholder syntax
The -x and -X options take a command template as a series of arguments (instead of a single string).
If you want to add additional options to fd after the command template, you can terminate it with a \;.
For example, fd -x echo \; pattern path treats pattern path as fd arguments instead of
passing them to echo. In practice, it is often clearer to write fd pattern path -x echo.
The syntax for generating commands is similar to that of GNU Parallel:
- {}: A placeholder token that will be replaced with the path of the search result
  (documents/images/party.jpg).
- {.}: Like {}, but without the file extension (documents/images/party).
- {/}: A placeholder that will be replaced by the basename of the search result (party.jpg).
- {//}: The parent of the discovered path (documents/images).
- {/.}: The basename, with the extension removed (party).
If you do not include a placeholder, fd automatically adds a {} at the end.
#### Parallel vs. serial execution
For -x/--exec, you can control the number of parallel jobs by using the -j/--threads option.
Use --threads=1 for serial execution.
Excluding specific files or directories  Copy Section
Sometimes we want to ignore search results from a specific subdirectory. For example, we might
want to search all hidden files and directories (-H) but exclude all matches from .git
directories. We can use the -E (or --exclude) option for this. It takes an arbitrary glob
pattern as an argument:

We can also use this to skip mounted directories:

.. or to skip certain file types:

To make exclude-patterns like these permanent, you can create a .fdignore file. They work like
.gitignore files, but are specific to fd. For example:

NOTE
fd also supports .ignore files that are used by other programs such as rg or ag.
If you want fd to ignore these patterns globally, you can put them in fd's global ignore file.
This is usually located in ~/.config/fd/ignore in macOS or Linux, and %APPDATA%\fd\ignore in
Windows.
You may wish to include .git/ in your fd/ignore file so that .git directories, and their contents
are not included in output if you use the --hidden option.
Deleting files  Copy Section
You can use fd to remove all files and directories that are matched by your search pattern.
If you only want to remove files, you can use the --exec-batch/-X option to call rm. For
example, to recursively remove all .DS_Store files, run:

If you are unsure, always call fd without -X rm first. Alternatively, use rms "interactive"
option:

If you also want to remove a certain class of directories, you can use the same technique. You will
have to use rms --recursive/-r flag to remove directories.
NOTE
There are scenarios where using fd … -X rm -r can cause race conditions: if you have a

path like …/foo/bar/foo/… and want to remove all directories named foo, you can end up in a
situation where the outer foo directory is removed first, leading to (harmless) *"'foo/bar/foo':
No such file or directory"* errors in the rm call.
Command-line options  Copy Section
This is the output of fd -h. To see the full set of command-line options, use fd --help which
also includes a much more detailed help text.

Note that options can be given after the pattern and/or path as well.
Benchmark  Copy Chapter
Let's search my home folder for files that end in [0-9].jpg. It contains ~750.000
subdirectories and about a 4 million files. For averaging and statistical analysis, I'm using
hyperfine. The following benchmarks are performed
with a "warm"/pre-filled disk-cache (results for a "cold" disk-cache show the same trends).
Let's start with find:

find is much faster if it does not need to perform a regular-expression search:

Now let's try the same for fd. Note that fd performs a regular expression
search by default. The options -u/--unrestricted option is needed here for
a fair comparison. Otherwise fd does not have to traverse hidden folders and
ignored paths (see below):

For this particular example, fd is approximately 23 times faster than find -iregex
and about 13 times faster than find -iname. By the way, both tools found the exact
same 546 files :smile:.
Note: This is one particular benchmark on one particular machine. While we have
performed a lot of different tests (and found consistent results), things might
be different for you! We encourage everyone to try it out on their own. See
this repository for all necessary scripts.
Concerning fd's speed, a lot of credit goes to the regex and ignore crates that are
also used in ripgrep (check it out!).
Troubleshooting  Copy Chapter
fd does not find my file!  does not find my file!')" title="Copy section prompt for LLMs"> Copy Section
Remember that fd ignores hidden directories and files by default. It also ignores patterns
from .gitignore files. If you want to make sure to find absolutely every possible file, always
use the options -u/--unrestricted option (or -HI to enable hidden and ignored files):

Also remember that by default, fd only searches based on the filename and
doesn't compare the pattern to the full path. If you want to search based on the
full path (similar to the -path option of find) you need to use the --full-path
(or -p) option.
Colorized output  Copy Section
fd can colorize files by extension, just like ls. In order for this to work, the environment
variable LS_COLORS has to be set. Typically, the value
of this variable is set by the dircolors command which provides a convenient configuration format
to define colors for different file formats.
On most distributions, LS_COLORS should be set already. If you are on Windows or if you are looking
for alternative, more complete (or more colorful) variants, see here,
here or
here.
fd also honors the NO_COLOR environment variable.
fd doesn't seem to interpret my regex pattern correctly  doesn't seem to interpret my regex pattern correctly')" title="Copy section prompt for LLMs"> Copy Section
A lot of special regex characters (like [], ^, $, ..) are also special characters in your
shell. If in doubt, always make sure to put single quotes around the regex pattern:

If your pattern starts with a dash, you have to add -- to signal the end of command line
options. Otherwise, the pattern will be interpreted as a command-line option. Alternatively,
use a character class with a single hyphen character:

"Command not found" for aliases or shell functions aliases or shell functions')" title="Copy section prompt for LLMs"> Copy Section
Shell aliases and shell functions can not be used for command execution via fd -x or
fd -X. In zsh, you can make the alias global via alias -g myalias="…". In bash,
you can use export -f my_function to make available to child processes. You would still
need to call fd -x bash -c 'my_function "$1"' bash. For other use cases or shells, use
a (temporary) shell script.
Integration with other programs  Copy Chapter
Using fd with fzf ')" title="Copy section prompt for LLMs"> Copy Section
You can use fd to generate input for the command-line fuzzy finder fzf: