sharkdp/fd

A simple, fast and user-friendly alternative to 'find'

fd

[中文] [한국어]

fd is a program to find entries in your filesystem. It is a simple, fast and user-friendly alternative to find. While it does not aim to support all of find's powerful functionality, it provides sensible (opinionated) defaults for a majority of use cases.

Installation • How to use • Troubleshooting

Sponsors

A special thank you goes to our biggest sponsors:

The $HOME of all things in the terminal.
_{Find your next CLI / TUI tool and more at Terminal Trove,}
^{Get updates on new tools on our newsletter.}

Features

• Intuitive syntax: fd PATTERN instead of find -iname '*PATTERN*'.
• Regular expression (default) and glob-based patterns.
• Very fast due to parallelized directory traversal.
• Uses colors to highlight different file types (same as ls).
• Supports parallel command execution
• Smart case: the search is case-insensitive by default. It switches to case-sensitive if the pattern contains an uppercase character*.
• Ignores hidden directories and files, by default.
• Ignores patterns from your .gitignore, by default.
• The command name is 50% shorter* than find :-).

Demo

How to use

First, to get an overview of all available command line options, you can either run fd -h for a concise help message or fd --help for a more detailed version.

Simple search

fd is designed to find entries in your filesystem. The most basic search you can perform is to run fd with a single argument: the search pattern. For example, assume that you want to find an old script of yours (the name included netflix):

> fd netfl
Software/python/imdb-ratings/netflix-details.py

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

The search pattern is treated as a regular expression. Here, we search for entries that start with x and end with rc:

> cd /etc
> fd '^x.*rc$'
X11/xinit/xinitrc
X11/xinit/xserverrc

The regular expression syntax used by fd is documented here.

Specifying the root directory

If we want to search a specific directory, it can be given as a second argument to fd:

> fd passwd /etc
/etc/default/passwd
/etc/pam.d/passwd
/etc/passwd

List all files, recursively

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):

> cd fd/tests
> fd
testenv
testenv/mod.rs
tests.rs

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 ^:

> fd . fd/tests/
testenv
testenv/mod.rs
tests.rs

Searching for a particular file extension

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:

> cd fd
> fd -e md
CONTRIBUTING.md
README.md

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

> fd -e rs mod
src/fshelper/mod.rs
src/lscolors/mod.rs
tests/testenv/mod.rs

Searching for a particular file name

To find files with exactly the provided search pattern, use the -g (or --glob) option:

> fd -g libc.so /usr
/usr/lib32/libc.so
/usr/lib/libc.so

Hidden and ignored files

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:

> fd pre-commit
> fd -H pre-commit
.git/hooks/pre-commit.sample

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:

> fd num_cpu
> fd -I num_cpu
target/debug/deps/libnum_cpus-f5ce7ef99006aa05.rlib

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

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.

> fd -p -g '**/.git/config'
> fd -p '.*/lesson-\d+/[a-z]+.(jpg|png)'

Command execution

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:

fd -e zip -x unzip

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:

fd -e h -e cpp -x 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.

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

fd -g 'test_*.py' -X vim

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:

fd … -X ls -lhd --color=always

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:

fd -e cpp -e cxx -e h -e hpp -X rg 'std::cout'

Convert all *.jpg files to *.png files:

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

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.

fd -tf -x md5sum > file_checksums.txt

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 \;.

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

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:

> fd -H -E .git …

We can also use this to skip mounted directories:

> fd -E /mnt/external-drive …

.. or to skip certain file types:

> fd -E '*.bak' …

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:

> cat ~/.fdignore
/mnt/external-drive
*.bak

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.

Deleting files

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:

> fd -H '^\.DS_Store$' -tf -X rm

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

> fd -H '^\.DS_Store$' -tf -X rm -i

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

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.

Usage: fd [OPTIONS] [pattern] [path]...

Arguments:
  [pattern]  the search pattern (a regular expression, unless '--glob' is used; optional)
  [path]...  the root directories for the filesystem search (optional)

Options:
  -H, --hidden                     Search hidden files and directories
  -I, --no-ignore                  Do not respect .(git|fd)ignore files
  -s, --case-sensitive             Case-sensitive search (default: smart case)
  -i, --ignore-case                Case-insensitive search (default: smart case)
  -g, --glob                       Glob-based search (default: regular expression)
  -a, --absolute-path              Show absolute instead of relative paths
  -l, --list-details               Use a long listing format with file metadata
  -L, --follow                     Follow symbolic links
  -p, --full-path                  Search full abs. path (default: filename only)
  -d, --max-depth <depth>          Set maximum search depth (default: none)
  -E, --exclude <pattern>          Exclude entries that match the given glob pattern
  -t, --type <filetype>            Filter by type: file (f), directory (d/dir), symlink (l),
                                   executable (x), empty (e), socket (s), pipe (p),
                                   block-device (b), char-device (c)
  -e, --extension <ext>            Filter by file extension
  -S, --size <size>                Limit results based on the size of files
      --changed-within <date|dur>  Filter by file modification time (newer than)
      --changed-before <date|dur>  Filter by file modification time (older than)
  -o, --owner <user:group>         Filter by owning user and/or group
  -x, --exec <cmd>...              Execute a command for each search result
  -X, --exec-batch <cmd>...        Execute a command with all search results at once
  -c, --color <when>               When to use colors [default: auto] [possible values: auto,
                                   always, never]
  -h, --help                       Print help (see more with '--help')
  -V, --version                    Print version

Benchmark

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:

Benchmark 1: find ~ -iregex '.*[0-9]\.jpg$'
  Time (mean ± σ):     19.922 s ±  0.109 s
  Range (min … max):   19.765 s … 20.065 s

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

Benchmark 2: find ~ -iname '*[0-9].jpg'
  Time (mean ± σ):     11.226 s ±  0.104 s
  Range (min … max):   11.119 s … 11.466 s

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):

Benchmark 3: fd -u '[0-9]\.jpg$' ~
  Time (mean ± σ):     854.8 ms ±  10.0 ms
  Range (min … max):   839.2 ms … 868.9 ms

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 😄.

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

fd does not find my file!

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):

> fd -u …

Colorized output

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

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:

> fd '^[A-Z][0-9]+$'

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:

> fd -- '-pattern'
> fd '[-]pattern'

"Command not found" for aliases or shell functions

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

Using fd with fzf

You can use fd to generate input for the command-line fuzzy finder fzf:

export FZF_DEFAULT_COMMAND='fd --type file'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

Then, you can type vim <Ctrl-T> on your terminal to open fzf and search through the fd-results.

Alternatively, you might like to follow symbolic links and include hidden files (but exclude .git folders):

export FZF_DEFAULT_COMMAND='fd --type file --follow --hidden --exclude .git'

You can even use fd's colored output inside fzf by setting:

export FZF_DEFAULT_COMMAND="fd --type file --color=always"
export FZF_DEFAULT_OPTS="--ansi"

For more details, see the Tips section of the fzf README.

Using fd with rofi

rofi is a graphical launch menu application that is able to create menus by reading from stdin. Piping fd output into rofis -dmenu mode creates fuzzy-searchable lists of files and directories.

Example

Create a case-insensitive searchable multi-select list of PDF files under your $HOME directory and open the selection with your configured PDF viewer. To list all file types, drop the -e pdf argument.

fd --type f -e pdf . $HOME | rofi -keep-right -dmenu -i -p FILES -multi-select | xargs -I {} xdg-open {}

To modify the list that is presented by rofi, add arguments to the fd command. To modify the search behaviour of rofi, add arguments to the rofi command.

Using fd with emacs

The emacs package find-file-in-project can use fd to find files.

After installing find-file-in-project, add the line (setq ffip-use-rust-fd t) to your ~/.emacs or ~/.emacs.d/init.el file.

In emacs, run M-x find-file-in-project-by-selected to find matching files. Alternatively, run M-x find-file-in-project to list all available files in the project.

Printing the output as a tree

To format the output of fd as a file-tree you can use the tree command with --fromfile:

❯ fd | tree --fromfile

This can be more useful than running tree by itself because tree does not ignore any files by default, nor does it support as rich a set of options as fd does to control what to print:

❯ fd --extension rs | tree --fromfile
.
├── build.rs
└── src
    ├── app.rs
    └── error.rs

On bash and similar you can simply create an alias:

❯ alias as-tree='tree --fromfile'

Using fd with xargs or parallel

Note that fd has a builtin feature for command execution with its -x/--exec and -X/--exec-batch options. If you prefer, you can still use it in combination with xargs:

> fd -0 -e rs | xargs -0 wc -l

Here, the -0 option tells fd to separate search results by the NULL character (instead of newlines). In the same way, the -0 option of xargs tells it to read the input in this way.

Installation

On Ubuntu

... and other Debian-based Linux distributions.

If you run Ubuntu 19.04 (Disco Dingo) or newer, you can install the officially maintained package:

sudo apt install fd-find

Note that the binary is called fdfind as the binary name fd is already used by another package. It is recommended that after installation, you add a link to fd by executing command ln -s $(which fdfind) ~/.local/bin/fd, in order to use fd in the same way as in this documentation. Make sure that $HOME/.local/bin is in your $PATH.

If you use an older version of Ubuntu, you can download the latest .deb package from the release page and install it via:

sudo dpkg -i fd_9.0.0_amd64.deb # adapt version number and architecture

On Debian

If you run Debian Buster or newer, you can install the officially maintained Debian package:

sudo apt-get install fd-find

Note that the binary is called fdfind as the binary name fd is already used by another package. It is recommended that after installation, you add a link to fd by executing command ln -s $(which fdfind) ~/.local/bin/fd, in order to use fd in the same way as in this documentation. Make sure that $HOME/.local/bin is in your $PATH.

On Fedora

Starting with Fedora 28, you can install fd from the official package sources:

dnf install fd-find

On Alpine Linux

You can install the fd package from the official sources, provided you have the appropriate repository enabled:

apk add fd

On Arch Linux

You can install the fd package from the official repos:

pacman -S fd

On Gentoo Linux

You can use the fd ebuild from the official repo:

emerge -av fd

On openSUSE Linux

You can install the fd package from the official repo:

zypper in fd

On Void Linux

You can install fd via xbps-install:

xbps-install -S fd

On RedHat Enterprise Linux 8/9 (RHEL8/9), Almalinux 8/9, EuroLinux 8/9 or Rocky Linux 8/9

You can install the fd package from Fedora Copr.

dnf copr enable tkbcopr/fd
dnf install fd

A different version using the slower malloc instead of jemalloc is also available from the EPEL8/9 repo as the package fd-find.

On macOS

You can install fd with Homebrew:

brew install fd

… or with MacPorts:

sudo port install fd

On Windows

You can download pre-built binaries from the release page.

Alternatively, you can install fd via Scoop:

scoop install fd

Or via Chocolatey:

choco install fd

Or via Winget:

winget install sharkdp.fd

On GuixOS

You can install the fd package from the official repo:

guix install fd

On NixOS / via Nix

You can use the Nix package manager to install fd:

nix-env -i fd

On FreeBSD

You can install the fd-find package from the official repo:

pkg install fd-find

From npm

On linux and macOS, you can install the fd-find package:

npm install -g fd-find

From source

With Rust's package manager cargo, you can install fd via:

cargo install fd-find

Note that rust version 1.77.2 or later is required.

make is also needed for the build.

From binaries

The release page includes precompiled binaries for Linux, macOS and Windows. Statically-linked binaries are also available: look for archives with musl in the file name.

Development

git clone https://github.com/sharkdp/fd

# Build
cd fd
cargo build

# Run unit tests and integration tests
cargo test

# Install
cargo install --path .

Maintainers

• sharkdp
• tmccombs
• tavianator

License

fd is distributed under the terms of both the MIT License and the Apache License 2.0.

See the LICENSE-APACHE and LICENSE-MIT files for license details.

fd's Issues

add option to switch off colors

Do not parse dir_colors for non-interactive terminal

Ignore .git, .svg etc.

only search filename by default?

flag to force color

Thanks for a great plugin!
fd doesn't use color when piping, however it can be useful. My usecase is for use with lotabout/skim.
ripgrep provides this behaviour with: rg --color=always

Add a homebrew formula for fd

Add a homebrew formula for fd.

Do not show files in .gitignore

• Parse .gitignore files in directories and ignore respective files
• Also, ignore .git folders (and similar for other VCS)

Add windows compatibility

This code is cross-platform save for the "executable file" check, which is only relevant on unix systems, and is done for the sole purpose of color-coding output lines.

I managed to make your code run on windows by adding conditional compilation operators to
use std::os::unix::fs::PermissionsExt; and to redefine the is_executable function on non-Linux systems.

add option to follow symlinks

Switch to the `walkdir` crate

walkdir is a recursive directory traversing crate with no redundant operations (stat etc). It's also used by the award-winning ripgrep tool.

We always wanted the speed without complexity; how about reusing existing code instead of hand rolling one?

add case-sensitive option

configurable search depth

Do not search hidden folders / files

Smart case

• fd pat -> case-insensitive search for pat (or PAT, or Pat, ...)
• fd Pat -> case-sensitive search for Pat

Make it fast

> cd /folder/with/lots/of/files

> time fnd jpg$ > /dev/null
fnd jpg$ > /dev/null  7,79s user 0,72s system 99% cpu 8,521 total

> time find -iname '*.jpg' > /dev/null
find -iname '*.jpg' > /dev/null  0,35s user 0,40s system 99% cpu 0,757 total

> time find -iregex '.*jpg$' > /dev/null
find -iregex '.*jpg$' > /dev/null  1,12s user 0,40s system 99% cpu 1,531 total

Provide more detailed '--help' output

clap has an option to show a more detailed help message if fd --help is called (as compared to fd -h):

• https://docs.rs/clap/2.26.2/clap/struct.Arg.html#method.long_help
• https://docs.rs/clap/2.26.2/clap/struct.App.html#method.long_about

We could use this to provide a more detailed help text for fd.

Upload to crates.io

Title is self-explanatory.

Use ~/.dir_colors to colorize path components

Detect non-interactive terminal

In order to pipe the output to other programs (or write to files)

option so search hidden folders

Support .ignore files using same format as rg and ag

Suggestion: Support .ignore files using same format as Ripgrep and The Silver Searcher ( rg and ag ).

Search filename only by default?

compile fails

this needs a 'static lifetime or the static_in_const feature, see #35897

changed ROOT_DIR assignment and compiles just fine.

69c69
< static ROOT_DIR : &str = "/";

static ROOT_DIR : &'static str = "/";

Consider making the CLI arguments consistent with ripgrep

For example: fd's -I/--no-ignore vs ripgrep's -u/--unrestricted.

(via DebuggingPanda on reddit)

Provide binary downloads with every release for easy installation

I'm a ripgrep user on windows (git bash) and ripgrep makes it really easy to install: https://github.com/BurntSushi/ripgrep#installation. In my case I just did $ choco install ripgrep

Would be great if fd would also provide binary downloads with every release:

ripgrep has first class support on Windows, Mac and Linux, with binary downloads available for every release.

I guess ripgrep has some automatic build tooling for this.

Try ignore::WalkParallel

Try to replace Walk by WalkParallel and investigate potential performance benefits / usability downsides (unsorted output).

(via @BurntSushi on reddit)

Bug parsing .gitignore

Hi! I'm not entirely sure, but I think I've experienced a bug parsing a git ignore file. I did (with 1.1):

$ cd /tmp/
$ git clone --depth 1 http://code.qt.io/git/qt/qtbase
Cloning into 'qtbase'...
remote: Counting objects: 22136, done.
remote: Compressing objects: 100% (16582/16582), done.
remote: Total 22136 (delta 5296), reused 16146 (delta 3446)
Receiving objects: 100% (22136/22136), 55.12 MiB | 2.70 MiB/s, done.
Resolving deltas: 100% (5296/5296), done.
$ cd qtbase/examples/
$ fd regular
widgets/doc/images/regularexpression-example.png
widgets/doc/src/regularexpression.qdoc
$ fd --no-ignore regular
widgets/tools/regularexpression
widgets/tools/regularexpression/regularexpressiondialog.h
widgets/tools/regularexpression/regularexpression.qrc
widgets/tools/regularexpression/regularexpression.pro
widgets/tools/regularexpression/regularexpressiondialog.cpp
widgets/doc/images/regularexpression-example.png
widgets/doc/src/regularexpression.qdoc

The .gitignore file of that repository may be a bit complex since, if I understand it properly, it uses a glob to add some files that later on are removed with a negative glob. I'm not entirely sure of the rules for it, but to me that is a bug in fd, since the files shown with --no-ignore are not ignored by git.

Thank you!

Slow inside VirtualBox shared folder

This might be a rare use case. But fd is 5x slower then find on a VirtualBox shared folder for me.
For the same data set fd is faster native. Also inside Virtualbox normal (non-shared) folder fd is faster.

Add colored output

Catch all possible exceptions

• Bad permissions...

Add usage examples to the README

For example:

• Searching for a substring: fd todo
• Searching for a substring in another location: fd apache /var/log
• Use fd as an alternative for ls -R: fd
• Searching all files (including hidden and ignored files): fd -HI ....
• Searching for a file extension (see also #56)
• Piping output to xargs: fd -0 ... | xargs -0 du -h
• Show absolute paths (either via -a or by providing an absolute path as destination)

Reproducible benchmarks

For example:

• Generate a lot of dummy files / directories in a controlled way by a shell script and run specific benchmarks within this test folder.
• Clone a certain (big) repository and run benchmarks within this repository (this is not 100% reproducible).

Show absolute paths by default if the base-path is absolute

--version

Please provide --version option to print the version.

$ fd --version
1.1.0

Show/search hidden files by default (or not)?

Possible options are [updated on 2017-06-05]:

• Add a convenient short option for --hidden (-h is for --help ...)

=> Done already, -H can be used (alongside --hidden) for searching hidden directories.

• Add a config file (~/.config/fdrc) where defaults (such as search_hidden=true) can be set

=> As discussed below, this will not be implemented for now. Aliases (such as alias fd="fd -HI").

• Add a status line below the search results to indicate that files were found in hidden/ignored directories (suggestion by @chrivers below).

Optional second argument: starting directory

Panic on broken pipe

fd does not exit cleanly when the stdout pipe is broken:

$ fd | head
[snip 10 lines]
thread 'main' panicked at 'failed printing to stdout: Broken pipe (os error 32)', /checkout/src/libstd/io/stdio.rs:693
note: Run with `RUST_BACKTRACE=1` for a backtrace.

Mention in doc you need rust version 1.17.0

Mention in doc you need rust version 1.17.0. I got compile errors using 1.16.0.

Case-insensitive by default

Colorize each component of a path

Filter on files or directories

I'd like a new option --type d for matching only directories and --type f for matching only files.

Add option to only search file extensions?

For example:

> fd -e rs
src/fshelper/mod.rs
src/lscolors/mod.rs
src/main.rs

Right now, this is only possible by searching for \.rs$.

Properly handle invalid UTF-8 in filenames

In particular, OsStr to String conversions may fail.

Quote by @BurntSushi on reddit:

You are converting all paths to strings before searching, which will probably blow up on you in some cases when file paths don't contain valid UTF-8. (And it does happen, because I had a similar bug in my own code.) On *nix at least, you can extract the raw &[u8] from a file path safely and then feed that into a regex::bytes::Regex (instead of regex::Regex).

add breadth first search option

Hi, thanks for this project! Adding bfs search would benefit interactively directory navigating.

Apply colour to text that matched regexp

Currently, the colours are only based on path: directories are a different colour, executable files are a different colour, etc.

It would be nice to highlight which parts of the path matched the current regexp. This would help understand why a given file matched the regexp.

Compile fails

On ubuntu 16.04 Linux pollux 4.4.0-78-generic #99-Ubuntu SMP Thu Apr 27 15:29:09 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux

What I did

Attempted to install

cargo install --git https://github.com/sharkdp/fd --verbose 

What I expected to happen

That fd would be installed to my path without a fuss, much like I experienced on my Mac

What actually happened

  Compiling fd v1.1.0 (https://github.com/sharkdp/fd#54f33e52)
     Running `rustc /home/eric/.cargo/git/checkouts/fd-9d671bc4b2af369e/54f33e5227e928fece1ed917749b6b4d4d23955f/src/main.rs --crate-name fd --crate-type bin -C opt-level=3 -C metadata=0ffa62fa1d203255 --out-dir /tmp/cargo-install.qbpI7XATIUGN/release --emit=dep-info,link -L dependency=/tmp/cargo-install.qbpI7XATIUGN/release/deps --extern ansi_term=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libansi_term-aa5dcc2affa8dc75.rlib --extern regex=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libregex-59f42a2a673f3a9d.rlib --extern clap=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libclap-bb4314a2ee3c5d44.rlib --extern ignore=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libignore-2e1cde877880acb9.rlib --extern atty=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libatty-acdf806defe52cbb.rlib`
error: no method named `split_off` found for type `std::string::String` in the current scope
   --> /home/eric/.cargo/git/checkouts/fd-9d671bc4b2af369e/54f33e5227e928fece1ed917749b6b4d4d23955f/src/lscolors/mod.rs:136:63
    |
136 |                         let extension = String::from(pattern).split_off(2);
    |                                                               ^^^^^^^^^

error: no method named `split_off` found for type `std::string::String` in the current scope
   --> /home/eric/.cargo/git/checkouts/fd-9d671bc4b2af369e/54f33e5227e928fece1ed917749b6b4d4d23955f/src/lscolors/mod.rs:140:62
    |
140 |                         let filename = String::from(pattern).split_off(1);
    |                                                              ^^^^^^^^^

error: aborting due to 2 previous errors

error: failed to compile `fd v1.1.0 (https://github.com/sharkdp/fd#54f33e52)`, intermediate artifacts can be found at `/tmp/cargo-install.qbpI7XATIUGN`

Caused by:
  Could not compile `fd`.

Caused by:
  process didn't exit successfully: `rustc /home/eric/.cargo/git/checkouts/fd-9d671bc4b2af369e/54f33e5227e928fece1ed917749b6b4d4d23955f/src/main.rs --crate-name fd --crate-type bin -C opt-level=3 -C metadata=0ffa62fa1d203255 --out-dir /tmp/cargo-install.qbpI7XATIUGN/release --emit=dep-info,link -L dependency=/tmp/cargo-install.qbpI7XATIUGN/release/deps --extern ansi_term=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libansi_term-aa5dcc2affa8dc75.rlib --extern regex=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libregex-59f42a2a673f3a9d.rlib --extern clap=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libclap-bb4314a2ee3c5d44.rlib --extern ignore=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libignore-2e1cde877880acb9.rlib --extern atty=/tmp/cargo-install.qbpI7XATIUGN/release/deps/libatty-acdf806defe52cbb.rlib` (exit code: 101)

I am still getting my bearings with rust but I will do my best to help -- this tool is a pleasure to use. Thanks for your work on this project thus far! 👍

The benchmarks are misleading

I think that the README should specifically mention that the regex search is faster(that's because the regex is slow in find).
The actual search is slower(it seems to imply that the find in general is faster).
Here is a more realistic usage of find, on an SSD(all runs are on warm cache):

time find -name '*.cpp'
...
real	0m0.447s
user	0m0.044s
sys	0m0.220s

And because fd uses patterns, it would look like this:

time fd '.*\.cpp$'
...
real	0m2.353s
user	0m0.100s
sys	0m1.240s

Weird, I just tested(while writing this) with -iregex and I got this:

time find -iregex '.*\.cpp$'
...
real	0m0.667s
user	0m0.128s
sys	0m0.400s

add option to show absolute paths

Test shell script doesn't work in macOS

I tried to run the test shell script in macOS and it returns this:

⋊> ~/c/r/fd on master ⨯ sh tests/test.sh                                                                                         14:25:13
mktemp: illegal option -- -
usage: mktemp [-d] [-q] [-t prefix] [-u] template ...
       mktemp [-d] [-q] [-u] -t prefix

Throw an error if the base directory does not exist

fd pattern /non-existent

should throw an error. Currently, it silently falls back to $CWD