2017-05-12 09:50:03 +00:00
# fd
2021-02-14 10:03:24 +00:00
2021-07-26 20:34:03 +00:00
[![CICD ](https://github.com/sharkdp/fd/actions/workflows/CICD.yml/badge.svg )](https://github.com/sharkdp/fd/actions/workflows/CICD.yml)
2017-09-17 11:17:40 +00:00
[![Version info ](https://img.shields.io/crates/v/fd-find.svg )](https://crates.io/crates/fd-find)
2021-02-14 10:03:24 +00:00
[[中文 ](https://github.com/chinanf-boy/fd-zh )]
[[한국어 ](https://github.com/spearkkk/fd-kor )]
2017-05-12 12:16:34 +00:00
2021-05-24 21:42:11 +00:00
`fd` is a program to find entries in your filesystem.
2021-02-14 10:17:04 +00:00
It is a simple, fast and user-friendly alternative to [`find` ](https://www.gnu.org/software/findutils/ ).
While it does not aim to support all of `find` 's powerful functionality, it provides sensible
(opinionated) defaults for a majority of use cases.
2017-05-09 21:45:02 +00:00
2021-02-14 10:03:24 +00:00
Quick links:
* [How to use ](#how-to-use )
* [Installation ](#installation )
* [Troubleshooting ](#troubleshooting )
2017-05-12 12:16:34 +00:00
## Features
2021-02-14 09:55:30 +00:00
2021-02-14 10:17:04 +00:00
* Intuitive syntax: `fd PATTERN` instead of `find -iname '*PATTERN*'` .
2021-02-14 10:22:10 +00:00
* Regular expression (default) and glob-based patterns.
* [Very fast ](#benchmark ) due to parallelized directory traversal.
* Uses colors to highlight different file types (same as *ls* ).
2021-02-14 18:50:50 +00:00
* Supports [parallel command execution ](#command-execution )
2017-05-13 08:21:38 +00:00
* Smart case: the search is case-insensitive by default. It switches to
case-sensitive if the pattern contains an uppercase
character[\*](http://vimdoc.sourceforge.net/htmldoc/options.html#'smartcase').
2017-06-02 18:42:55 +00:00
* Ignores hidden directories and files, by default.
* Ignores patterns from your `.gitignore` , by default.
2017-06-02 18:34:02 +00:00
* The command name is *50%* shorter[\*](https://github.com/ggreer/the_silver_searcher) than
`find` :-).
2017-05-09 21:29:14 +00:00
2017-05-12 22:05:00 +00:00
## Demo
2017-05-12 22:07:32 +00:00
2018-01-28 12:32:26 +00:00
![Demo ](doc/screencast.svg )
2017-05-09 21:35:34 +00:00
2021-02-14 10:03:24 +00:00
## How to use
2017-10-06 14:31:04 +00:00
2017-10-22 17:16:49 +00:00
First, to get an overview of all available command line options, you can either run
2021-02-14 10:07:44 +00:00
[`fd -h` ](#command-line-options ) for a concise help message or `fd --help` for a more detailed
2017-10-22 17:16:49 +00:00
version.
2017-10-06 14:31:04 +00:00
2017-10-22 17:16:49 +00:00
### Simple search
2017-10-15 20:27:02 +00:00
2017-10-22 17:16:49 +00:00
*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` ):
``` bash
> fd netfl
Software/python/imdb-ratings/netflix-details.py
2017-10-15 20:27:02 +00:00
```
2017-10-22 17:16:49 +00:00
If called with just a single argument like this, *fd* searches the current directory recursively
for any entries that *contain* the pattern `netfl` .
2017-10-15 20:27:02 +00:00
2017-10-22 17:16:49 +00:00
### Regular expression search
2017-10-06 14:31:04 +00:00
2017-10-22 17:16:49 +00:00
The search pattern is treated as a regular expression. Here, we search for entries that start
with `x` and end with `rc` :
``` bash
> cd /etc
> fd '^x.*rc$'
X11/xinit/xinitrc
X11/xinit/xserverrc
2017-10-06 14:31:04 +00:00
```
2021-02-14 09:47:34 +00:00
The regular expression syntax used by `fd` is [documented here ](https://docs.rs/regex/1.0.0/regex/#syntax ).
2020-10-09 14:30:23 +00:00
2017-10-22 17:16:49 +00:00
### Specifying the root directory
2017-10-06 14:31:04 +00:00
2018-01-10 12:02:25 +00:00
If we want to search a specific directory, it can be given as a second argument to *fd* :
2017-10-22 17:16:49 +00:00
``` bash
> fd passwd /etc
/etc/default/passwd
/etc/pam.d/passwd
/etc/passwd
2017-10-15 20:27:02 +00:00
```
2021-02-14 09:51:40 +00:00
### List all files, recursively
2017-10-06 14:31:04 +00:00
2017-10-22 17:16:49 +00:00
*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` ):
``` bash
> cd fd/tests
> fd
testenv
testenv/mod.rs
tests.rs
2017-10-06 14:31:04 +00:00
```
2019-01-09 21:12:17 +00:00
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 `^` :
``` bash
> fd . fd/tests/
testenv
testenv/mod.rs
tests.rs
```
2017-10-22 17:16:49 +00:00
### Searching for a particular file extension
2017-10-06 14:31:04 +00:00
2017-10-22 17:16:49 +00:00
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:
``` bash
> cd fd
> fd -e md
CONTRIBUTING.md
README.md
2017-10-06 14:31:04 +00:00
```
2017-10-22 17:16:49 +00:00
The `-e` option can be used in combination with a search pattern:
``` bash
> fd -e rs mod
src/fshelper/mod.rs
src/lscolors/mod.rs
tests/testenv/mod.rs
2017-10-06 14:31:04 +00:00
```
2017-10-22 17:16:49 +00:00
### 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:
``` bash
> fd pre-commit
> fd -H pre-commit
.git/hooks/pre-commit.sample
2017-10-06 14:31:04 +00:00
```
2017-10-22 17:16:49 +00:00
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
2018-02-09 13:35:58 +00:00
this behavior, we can use the `-I` (or `--no-ignore` ) option:
2017-10-22 17:16:49 +00:00
``` bash
> fd num_cpu
> fd -I num_cpu
target/debug/deps/libnum_cpus-f5ce7ef99006aa05.rlib
2017-10-06 14:31:04 +00:00
```
2017-10-22 17:16:49 +00:00
To really search *all* files and directories, simply combine the hidden and ignore features to show
everything (`-HI`).
2017-10-15 20:27:02 +00:00
2021-02-14 18:50:50 +00:00
### Command execution
2021-02-14 09:52:53 +00:00
2021-02-14 18:50:50 +00:00
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:
2020-12-07 23:07:02 +00:00
2021-02-14 18:50:50 +00:00
* 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
2021-02-14 18:59:53 +00:00
Recursively find all zip archives and unpack them:
2020-12-07 23:07:02 +00:00
``` bash
2021-02-14 18:50:50 +00:00
fd -e zip -x unzip
2020-12-07 23:07:02 +00:00
```
2021-02-14 18:59:53 +00:00
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).
2020-12-07 23:07:02 +00:00
2021-02-14 18:50:50 +00:00
Find all `*.h` and `*.cpp` files and auto-format them inplace with `clang-format -i` :
2020-12-07 23:07:02 +00:00
``` bash
2021-02-14 18:50:50 +00:00
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.
2020-12-07 23:07:02 +00:00
2021-02-14 18:50:50 +00:00
Find all `test_*.py` files and open them in your favorite editor:
``` bash
fd -g 'test_*.py' -X vim
```
2021-02-14 18:59:53 +00:00
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` .
2020-12-07 23:07:02 +00:00
2021-02-14 18:59:53 +00:00
To see details like file permissions, owners, file sizes etc., you can tell `fd` to show them
by running `ls` for each result:
2021-02-14 18:50:50 +00:00
``` bash
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` .
2020-12-07 23:07:02 +00:00
2021-02-14 18:50:50 +00:00
Convert all `*.jpg` files to `*.png` files:
``` bash
fd -e jpg -x convert {} {.}.png
2020-12-07 23:07:02 +00:00
```
2021-02-14 18:50:50 +00:00
Here, `{}` is a placeholder for the search result. `{.}` is the same, without the file extension.
See below for more details on the placeholder syntax.
#### 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 `\;` .
2020-12-07 23:07:02 +00:00
2021-03-14 19:03:09 +00:00
The syntax for generating commands is similar to that of [GNU Parallel ](https://www.gnu.org/software/parallel/ ):
2020-12-07 23:07:02 +00:00
- `{}` : 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`).
2021-02-14 18:50:50 +00:00
- `{//}` : 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
2020-12-07 23:07:02 +00:00
2021-02-14 18:50:50 +00:00
For `-x` /`--exec`, you can control the number of parallel jobs by using the `-j` /`--threads` option.
Use `--threads=1` for serial execution.
2020-12-07 23:07:02 +00:00
2021-02-14 18:51:10 +00:00
### 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:
``` bash
> fd -H -E .git …
```
We can also use this to skip mounted directories:
``` bash
> fd -E /mnt/external-drive …
```
.. or to skip certain file types:
``` bash
> 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:
``` bash
> 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.
2019-05-31 12:30:54 +00:00
### 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:
``` bash
> fd -H '^\.DS_Store$' -tf -X rm
```
If you are unsure, always call `fd` without `-X rm` first. Alternatively, use `rm` s "interactive"
option:
``` bash
> 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 `rm` s `--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.
2021-02-14 10:03:24 +00:00
### Command-line options
2021-02-14 09:57:09 +00:00
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 [FLAGS/OPTIONS] [< pattern > ] [< path > ...]
FLAGS:
-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 path (default: file-/dirname only)
-0, --print0 Separate results by the null character
-h, --help Prints help information
-V, --version Prints version information
OPTIONS:
-d, --max-depth < depth > Set maximum search depth (default: none)
-t, --type < filetype > ... Filter by type: file (f), directory (d), symlink (l),
executable (x), empty (e), socket (s), pipe (p)
-e, --extension < ext > ... Filter by file extension
-x, --exec < cmd > Execute a command for each search result
-X, --exec-batch < cmd > Execute a command with all search results at once
-E, --exclude < pattern > ... Exclude entries that match the given glob pattern
-c, --color < when > When to use colors: never, *auto* , always
-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)
ARGS:
< pattern > the search pattern - a regular expression unless '--glob' is used (optional)
< path > ... the root directory for the filesystem search (optional)
```
## Benchmark
Let's search my home folder for files that end in `[0-9].jpg` . It contains ~190.000
subdirectories and about a million files. For averaging and statistical analysis, I'm using
[hyperfine ](https://github.com/sharkdp/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 ± σ ): 7.236 s ± 0.090 s
Range (min … max): 7.133 s … 7.385 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 ± σ ): 3.914 s ± 0.027 s
Range (min … max): 3.876 s … 3.964 s
```
Now let's try the same for `fd` . Note that `fd` *always* performs a regular expression
search. The options `--hidden` and `--no-ignore` are needed for a fair comparison,
otherwise `fd` does not have to traverse hidden folders and ignored paths (see below):
```
Benchmark #3: fd -HI '.*[0-9]\.jpg$' ~
Time (mean ± σ ): 811.6 ms ± 26.9 ms
Range (min … max): 786.0 ms … 870.7 ms
```
For this particular example, `fd` is approximately nine times faster than `find -iregex`
and about five times faster than `find -iname` . By the way, both tools found the exact
same 20880 files :smile:.
Finally, let's run `fd` without `--hidden` and `--no-ignore` (this can lead to different
search results, of course). If *fd* does not have to traverse the hidden and git-ignored
folders, it is almost an order of magnitude faster:
```
Benchmark #4: fd '[0-9]\.jpg$' ~
Time (mean ± σ ): 123.7 ms ± 6.0 ms
Range (min … max): 118.8 ms … 140.0 ms
```
**Note**: This is *one particular* benchmark on *one particular* machine. While I have
performed quite a lot of different tests (and found consistent results), things might
be different for you! I encourage everyone to try it out on their own. See
[this repository ](https://github.com/sharkdp/fd-benchmarks ) for all necessary scripts.
Concerning *fd* 's speed, the main credit goes to the `regex` and `ignore` crates that are also used
in [ripgrep ](https://github.com/BurntSushi/ripgrep ) (check it out!).
2021-02-14 09:52:53 +00:00
## Troubleshooting
2019-01-09 21:22:30 +00:00
2021-02-14 09:55:30 +00:00
### Colorized output
`fd` can colorize files by extension, just like `ls` . In order for this to work, the environment
variable [`LS_COLORS` ](https://linux.die.net/man/5/dir_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 ](https://github.com/sharkdp/vivid ),
[here ](https://github.com/seebi/dircolors-solarized ) or
[here ](https://github.com/trapd00r/LS_COLORS ).
`fd` also honors the [`NO_COLOR` ](https://no-color.org/ ) environment variable.
2021-02-14 09:52:53 +00:00
### `fd` does not find my file!
2019-01-09 21:22:30 +00:00
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 `-H` and `-I` to disable these two features:
``` bash
> fd -HI …
```
2021-02-14 09:52:53 +00:00
### `fd` doesn't seem to interpret my regex pattern correctly
2019-01-09 21:22:30 +00:00
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:
``` bash
> 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:
``` bash
> fd -- '-pattern'
> fd '[-]pattern'
```
2021-02-14 09:52:53 +00:00
## Integration with other programs
2018-04-12 14:17:00 +00:00
2021-02-14 09:52:53 +00:00
### Using fd with `fzf`
2018-01-02 21:26:38 +00:00
You can use *fd* to generate input for the command-line fuzzy finder [fzf ](https://github.com/junegunn/fzf ):
``` bash
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):
``` bash
export FZF_DEFAULT_COMMAND='fd --type file --follow --hidden --exclude .git'
```
You can even use fd's colored output inside fzf by setting:
``` bash
export FZF_DEFAULT_COMMAND="fd --type file --color=always"
export FZF_DEFAULT_OPTS="--ansi"
```
For more details, see the [Tips section ](https://github.com/junegunn/fzf#tips ) of the fzf README.
2018-04-12 14:17:00 +00:00
2021-04-14 12:17:18 +00:00
### Using fd with `rofi`
[*rofi* ](https://github.com/davatorium/rofi ) is a graphical launch menu application that is able to create menus by reading from *stdin* . Piping `fd` output into `rofi` s `-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.
``` bash
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.
2021-02-14 09:52:53 +00:00
### Using fd with `emacs`
2018-04-12 14:17:00 +00:00
2018-04-13 20:34:32 +00:00
The emacs package [find-file-in-project ](https://github.com/technomancy/find-file-in-project ) can
use *fd* to find files.
2018-04-12 14:17:00 +00:00
2018-04-13 20:34:32 +00:00
After installing `find-file-in-project` , add the line `(setq ffip-use-rust-fd t)` to your
`~/.emacs` or `~/.emacs.d/init.el` file.
2018-04-12 14:17:00 +00:00
2018-04-13 20:34:32 +00:00
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.
2020-01-19 15:16:25 +00:00
2021-02-14 09:55:30 +00:00
### Printing the output as a tree
2020-05-13 04:39:28 +00:00
To format the output of `fd` similar to the `tree` command, install [`as-tree`] and pipe the output
of `fd` to `as-tree` :
```bash
fd | as-tree
```
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:
```bash
❯ fd --extension rs | as-tree
.
├── build.rs
└── src
├── app.rs
└── error.rs
```
For more information about `as-tree` , see [the `as-tree` README][`as-tree`].
[`as-tree`]: https://github.com/jez/as-tree
2021-02-14 10:27:44 +00:00
### Using fd with `xargs` or `parallel`
2021-02-14 18:50:50 +00:00
Note that `fd` has a builtin feature for [command execution ](#command-execution ) with
2021-02-14 10:27:44 +00:00
its `-x` /`--exec` and `-X` /`--exec-batch` options. If you prefer, you can still use
it in combination with `xargs` :
``` bash
> 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.
2020-12-07 05:54:00 +00:00
## Installation
[![Packaging status ](https://repology.org/badge/vertical-allrepos/fd-find.svg )](https://repology.org/project/fd-find/versions)
### 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 ](https://packages.ubuntu.com/fd-find ):
```
sudo apt install fd-find
```
Note that the binary is called `fdfind` as the binary name `fd` is already used by another package.
2021-02-12 05:52:35 +00:00
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.
2021-07-20 15:05:01 +00:00
Make sure that `$HOME/.local/bin` is in your `$PATH` .
2020-12-07 05:54:00 +00:00
If you use an older version of Ubuntu, you can download the latest `.deb` package from the
[release page ](https://github.com/sharkdp/fd/releases ) and install it via:
``` bash
2020-12-07 17:57:45 +00:00
sudo dpkg -i fd_8.2.1_amd64.deb # adapt version number and architecture
2020-12-07 05:54:00 +00:00
```
### On Debian
If you run Debian Buster or newer, you can install the
[officially maintained Debian package ](https://tracker.debian.org/pkg/rust-fd-find ):
```
sudo apt-get install fd-find
```
Note that the binary is called `fdfind` as the binary name `fd` is already used by another package.
2021-02-12 05:52:35 +00:00
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.
2021-07-20 15:05:01 +00:00
Make sure that `$HOME/.local/bin` is in your `$PATH` .
2020-12-07 05:54:00 +00:00
### On Fedora
Starting with Fedora 28, you can install `fd` from the official package sources:
``` bash
dnf install fd-find
```
For older versions, you can use this [Fedora copr ](https://copr.fedorainfracloud.org/coprs/keefle/fd/ ) to install `fd` :
``` bash
dnf copr enable keefle/fd
dnf install fd
```
### On Alpine Linux
You can install [the fd package ](https://pkgs.alpinelinux.org/packages?name=fd )
from the official sources, provided you have the appropriate repository enabled:
```
apk add fd
```
### On Arch Linux
You can install [the fd package ](https://www.archlinux.org/packages/community/x86_64/fd/ ) from the official repos:
```
pacman -S fd
```
### On Gentoo Linux
You can use [the fd ebuild ](https://packages.gentoo.org/packages/sys-apps/fd ) from the official repo:
```
emerge -av fd
```
### On openSUSE Linux
You can install [the fd package ](https://software.opensuse.org/package/fd ) from the official repo:
```
zypper in fd
```
### On Void Linux
You can install `fd` via xbps-install:
```
xbps-install -S fd
```
### On macOS
You can install `fd` with [Homebrew ](https://formulae.brew.sh/formula/fd ):
```
brew install fd
```
… or with MacPorts:
```
sudo port install fd
```
### On Windows
You can download pre-built binaries from the [release page ](https://github.com/sharkdp/fd/releases ).
Alternatively, you can install `fd` via [Scoop ](http://scoop.sh ):
```
scoop install fd
```
Or via [Chocolatey ](https://chocolatey.org ):
```
choco install fd
```
### On NixOS / via Nix
You can use the [Nix package manager ](https://nixos.org/nix/ ) to install `fd` :
```
nix-env -i fd
```
### On FreeBSD
You can install [the fd-find package ](https://www.freshports.org/sysutils/fd ) from the official repo:
```
pkg install fd-find
```
### From NPM
On linux and macOS, you can install the [fd-find ](https://npm.im/fd-find ) package:
```
npm install -g fd-find
```
### From source
With Rust's package manager [cargo ](https://github.com/rust-lang/cargo ), you can install *fd* via:
```
cargo install fd-find
```
2021-07-27 06:38:09 +00:00
Note that rust version *1.42.0* or later is required.
2020-12-07 05:54:00 +00:00
### From binaries
2021-06-19 17:36:22 +00:00
The [release page ](https://github.com/sharkdp/fd/releases ) includes precompiled binaries for Linux, macOS and Windows. Statically-linked binaries are also available: look for archives with `musl` in the file name.
2020-12-07 05:54:00 +00:00
## Development
```bash
git clone https://github.com/sharkdp/fd
# Build
cd fd
cargo build
# Run unit tests and integration tests
cargo test
# Install
cargo install --path .
```
2020-06-10 05:42:49 +00:00
## Maintainers
- [sharkdp ](https://github.com/sharkdp )
- [tmccombs ](https://github.com/tmccombs )
2020-01-19 15:16:25 +00:00
## License
2021-02-14 09:51:30 +00:00
Copyright (c) 2017-2021 The fd developers
2020-01-19 15:16:25 +00:00
`fd` is distributed under the terms of both the MIT License and the Apache License 2.0.
See the [LICENSE-APACHE ](LICENSE-APACHE ) and [LICENSE-MIT ](LICENSE-MIT ) files for license details.