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



Build Status Build status Version info [中文] [한국어]

fd is a program to find entries in your filesytem. 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.

Quick links:


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



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

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$'

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

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

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/

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

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

> fd -e rs mod

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

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

To really search all files and directories, simply combine the hidden and ignore features to show everything (-HI).

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.


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.

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.

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

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.

    fd [FLAGS/OPTIONS] [<pattern>] [<path>...]

    -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

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

    <pattern>    the search pattern - a regular expression unless '--glob' is used (optional)
    <path>...    the root directory for the filesystem search (optional)


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

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 for all necessary scripts.

Concerning fd's speed, the main credit goes to the regex and ignore crates that are also used in ripgrep (check it out!).


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 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 -H and -I to disable these two features:

> fd -HI …

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'

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'

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 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 similar to the tree command, install as-tree and pipe the output of fd to as-tree:

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:

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

For more information about as-tree, see the as-tree README.

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.


Packaging status

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.

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_8.2.1_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.

On Fedora

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

dnf install fd-find

For older versions, you can use this Fedora copr to install fd:

dnf copr enable keefle/fd
dnf install fd

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

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.36.0 or later is required.

From binaries

The release page includes precompiled binaries for Linux, macOS and Windows.


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

# Build
cd fd
cargo build

# Run unit tests and integration tests
cargo test

# Install
cargo install --path .



Copyright (c) 2017-2021 The fd developers

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.

  • Colourful output on Windows (in Git Bash)

    Colourful output on Windows (in Git Bash)

    I've seen the talks leading up to colour output support, namely #129 #137

    However, bat works and emits a colourful output, by default. Below is bat ~/Desktop/desktop.ini:

    bat output with colours working

    It seems colourful output can be supported.

    I'm using Git Bash 2.20-something. Git Bash can be set up to run with MinTTY, which gets you a nice terminal emulator, unlike that of the default cmd. Git Bash is the nicest and best way to get Bash shell environment running for Windows, and this is like the only Shell I use on Windows, so it's surprising that if bat colours work, fd does not.

    help wanted good first issue windows 
    opened by whisperity 47
  • Add `--ignore-file` flag

    Add `--ignore-file` flag

    Basically identical to rg's same flag.

    The benefit of this is that sometimes you don't want to ignore every gitignore file found in the search path, but you do want to specifically ignore some files, so this flag comes in handy. Also, if I'm searching from ~, I don't expect the gitignore file several levels down in some project to get picked up by default.

    opened by alok 35
  • Without pattern 'find' ~8x faster than 'fd'

    Without pattern 'find' ~8x faster than 'fd'

    OS: Linux 4.14.3-1-ARCH FS: ext4 fd: 6.0.0

    Simple test:

    > time find > /dev/null
    find > /dev/null  0.00s user 0.06s system 97% cpu 0.065 total
    > time fd --color never -HI > /dev/null
    fd --color never -HI > /dev/null  0.75s user 0.10s system 133% cpu 0.631 total

    Also fd with pattern faster ~8x than fd without pattern:

    > time fd --color never -HI '.zshrc' > /dev/null
    fd --color never -HI '.zshrc' > /dev/null  0.18s user 0.06s system 325% cpu 0.073 total
    > time fd --color never -HI > /dev/null
    fd --color never -HI > /dev/null  0.74s user 0.06s system 132% cpu 0.608 total
    help wanted performance 
    opened by dtcyganok 33
  • Implement the --exec flag

    Implement the --exec flag

    With this change, the --exec flag will be fully functional with a syntax similar to GNU Parallel. The argument that follows the --exec flag will be used as the command template, and each path discovered is distributed across a job pool for command generation & execution.

    The README has been updated to demonstrate the new feature.

    Closes #84

    opened by mmstick 31
  • Display directories with trailing slashes

    Display directories with trailing slashes


    It will be great if there will be a possibility to have directories displayed with a trailing "/" (as an option or not). When you don't use colors, there is no way to distinct directories from files.


    feature-request good first issue 
    opened by rockandska 29
  • Consider relicensing under MIT/Apache-2.0

    Consider relicensing under MIT/Apache-2.0

    Some time ago, there were requests that MIT or Apache-2.0 licensed Rust projects would be relicensed under MIT/Apache-2.0 dual license, see here.

    Please consider if this would be acceptable for this project as well.

    opened by Detegr 29
  • Thoughts on non-zero exit code for no matches?

    Thoughts on non-zero exit code for no matches?

    grep returns a non-zero exit code when no matches are found, making it easy to include in shell scripts and if conditions directly without having to shell out to test to analyze the results.

    What are your thoughts on having fd do the same so that fd not-exists and fd exists have differing exit codes that could be directly checked?

    feature-request good first issue 
    opened by mqudsi 26
  • fd can get stuck when ran onto the whole FS from the root

    fd can get stuck when ran onto the whole FS from the root

    The ran command is just fd foobar /. It gets stuck and never end. I sadly was unable to understand what's causing it. I can investigate to give answers if you have some ideas about what else could I check.

    Below is the partition's setup:

    # lsblk
    sda              8:0    0 223,6G  0 disk  
    ├─sda1           8:1    0   512M  0 part  /boot/efi
    ├─sda2           8:2    0   200M  0 part  
    │ └─cryptboot  254:3    0   198M  0 crypt /boot
    └─sda3           8:3    0 222,9G  0 part  
      └─lvm        254:0    0 222,9G  0 crypt 
        ├─vg0-swap 254:1    0     8G  0 lvm   [SWAP]
        └─vg0-root 254:2    0 214,9G  0 lvm   /

    EDIT: Issue is reproducing everytime on this Archlinux setup. Couldn't reproduce it on another Archlinux with unencrypted system.

    opened by Porkepix 26
  • Implement multiple suffixes extension support with tests (#214)

    Implement multiple suffixes extension support with tests (#214)

    Instead of relying on Path.extension(), the path is checked to see if it ends with any of the given extensions. The only quirk was to compare .ext to the end of the path instead of ext, or else we could have matched wrong files.

    I had several ways of doing so in mind, and while not being the quicket this one should be the most obvious, and I don't think it's really necessary to micro-optimize here.

    I also added a few test cases that should prevent regressions.

    opened by althonos 23
  • Append trailing path separators to directories

    Append trailing path separators to directories

    Solves #436.

    Add a trailing slash (or custom path separator, if provided) to directories. This only affects output; path args for exec are processed normally.

    opened by yyogo 22
  • fd is vulnerable to filenames with leading dashes

    fd is vulnerable to filenames with leading dashes

    Describe the bug you encountered: When piping relative paths from fd to utilities like xargs, the program does not return paths, but rather file names. For instance, in a directory containing foo.txt, the command fd -t f -0 | xargs -0 -I% rm % passes foo.txt to xargs rather than ./foo.txt.

    If the directory contains files with leading dashes, such as the file -rf, commands like rm interpret this as options rather than a valid path. Certain commands have the end-of-options -- parameter, but not all do, and the burden falls on the user to use --. find fixes this problem by always returning absolute or relative paths; returning ./-rf would not pose a problem for further processing.

    Filenames with dashes are not limited to deliberately malicious constructs. I have found program-generated files in .config folders full of leading dashes, as well as media files saved by id, whose id happened to have a leading dash.

    Describe what you expected to happen: when searching by relative paths, fd should return paths, i.e. filenames prefixed by ./ to avoid problems like the above; especially when the output of fd is in a pipeline.

    What version of fd are you using? fd 8.2.1

    Which operating system / distribution are you on? Linux 5.11.12-arch1-1 x86_64

    LSB Version: 1.4 Distributor ID: Arch Description: Arch Linux Release: rolling Codename: n/a

    bug help wanted 
    opened by ykonstant1 21
  • Add release checklist for maintainers

    Add release checklist for maintainers

    Adapted from bats release checklist which has worked quite well so far (https://github.com/sharkdp/bat/blob/master/doc/release-checklist.md).

    Rendered version: https://github.com/sharkdp/fd/blob/add-release-checklist/doc/release-checklist.md

    opened by sharkdp 0
  • RFC: --exec with placeholder corresponding to regex groups/ocurrences

    RFC: --exec with placeholder corresponding to regex groups/ocurrences


    Allow the groups/occurrences matched by the regex pattern over the filename/path to be used as placeholders for commands executed with the flag --exec.

    Note however that it's just a proof-of-concept yet. I just have written for checking if it could become accepted. The code is far from done but at least it's possible to run and play with any supported regex and the placeholder support.

    So, please share your opinion.


    • Allow the use of regex group constructs for extracting specific pieces from the files/directories name.
    • Allow capturing as many occurrences as matched by the regex pattern and use them as placeholders.
    • Allow specifying a default text when the group/occurrence is not matched.

    Uses cases:

    Renaming or moving files and folders:
    fd '(.+)( copy.*)(\.\w+)$' -x mv "{}" "{1}.{3}"
    Adding prefixes, text, and extensions to file names:
    fd '([\w-]+)(\.[\w-]+)?$' -t f -x echo "|| {} |groups| {//}/{1}{2:-.ext}"


    From the help:

    -x, --exec <cmd>...
        Execute a command for each search result in parallel (use --threads=1 for sequential command execution). All positional
        arguments following --exec are considered to be arguments to the command - not to fd. It is therefore recommended to
        place the '-x'/'--exec' option last.
        The following placeholders are substituted before the command is executed:
          '{}':   path (of the current search result)
          '{/}':  basename
          '{//}': parent directory
          '{.}':  path without file extension
          '{/.}': basename without file extension
    +     '{N}':  text matched by the N-th group in the first pattern occurrence. Text outside groups is discarded.
    +     '{M.N}': text matched in the M-th pattern occurrence by the N-th group over the path or filename.
    +     '{N:-D}': text matched by the optional occurrence/group or defaults to 'D' when not matched.
    +   Obs:
    +   - Using 0 for M/N substitutes by the text from all groups or all occurrences respectively.
        - If no placeholder is present, an implicit "{}" at the end is assumed.


    cargo run -- '(\w+)\.(\w+)$' -x echo "|| {} |groups| {//}/{2}.{1}" | column -t
    cargo run -- '([a-zA-Z0-9]+)([\._-]\w+)\.(\w+)$' -x echo "|| {} |groups| {//}/{1}.{3}" | column -t
    cargo run -- '([\w-]+)(\.[\w-]+)?$' -t f -x echo "|| {} |groups| {//}/{1}{2:-.ext}" | column -t
    cargo run -- '([\./])([\w\.]+)' -p  -x echo "|| {} |matches| {1.0} {2.0} {3.0} {4.0} {5.0} {6.0} {7.0} {8.0} {9.0} {10.0}" | column -t
    cargo run -- '(\w+)([_-]+\w+)(\.\w+)?' -x echo "|/| {/} |0| {0} {0.1} {0.2} {0.3} |1| {1.0} {1.1} {1.2} {1.3}" | column -t
    cargo run -- '([-_\.]+)?([a-zA-Z0-9])([a-zA-Z0-9]+)' -x echo "|/| {/} |0| {0} {0.1} {0.2} {0.3} |1| {1.0} {1.1} {1.2} {1.3} |2| {2.0} {2.1} {2.2} {2.3}" | column -t
    cargo run -- '(/)(\w+)(\.\w+)?' -p -a -x echo "|| {} |groups| {0.1} {0.2} {0.3}" | column -t
    opened by juarezr 1
  • find like options: --name and path

    find like options: --name and path

    firstly, #1111 yes I know.

    So here's what I'd like if possible. Number one priority directory and name.

    fd . --name foo

    should be equivalent to fd --glob foo .

    The problem of course how to switch, perhaps fd --mode=find, or a config file option. with fd --mode=find you could simply write an alias. You could trigger it with --name but that would make it harder to eventually add other options.

    note: obviously . is silly with fd, but it's what I'm used to, tbh.

    oh, and a find mode should invert ignore and ignoring of hidden files #1116

    opened by xenoterracide 0
  • Getting random ' panicked at 'assertion failed"">

    Getting random "thread '' panicked at 'assertion failed"

    What version of fd are you using? fd 8.4.0

    Brand new Macbook M1, installed yesterday with brew install fd.

    I'm getting randomly the following exception:

    zsmac16 user ~/Documents $ fd syncthing
    thread '<unnamed>' panicked at 'assertion failed: `(left == right)`
      left: `105553171240160`,
     right: `0`: This is a known bug in the Rust standard library. See https://github.com/rust-lang/rust/issues/39364', /private/tmp/rust-20220304-34642-f8s218/rustc-1.59.0-src/library/std/src/sync/mpsc/shared.rs:251:13
    note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
    thread 'main' panicked at 'assertion failed: `(left == right)`
      left: `105553171240160`,
     right: `0`', /private/tmp/rust-20220304-34642-f8s218/rustc-1.59.0-src/library/std/src/sync/mpsc/shared.rs:497:9

    Then I re-run the same command immediately and everything is OK.

    Is this related to homebrew install or something else?

    opened by hyperknot 3
  • Ignore gitignore rules when explicitly searching inside an ignored dir

    Ignore gitignore rules when explicitly searching inside an ignored dir

    To improve usability, I think it would be good to ignore the rules in .gitignore when the user tries to search inside a dir that is already ignored. This will result in far fewer "gotcha" moments. For example, assume I am searching inside a Rust project:

    fd rmeta
    # no results because all *.rmeta files are in the target/ dir, which is in .gitignore
    fd rmeta target/
    # No results because .gitignore has a `*.rmeta` rule too. Instead, I think it
    # should show lots of results because I am searching explicitly inside an ignored dir

    Note that .gitignore may have multiple rules, e.g. target/ and *.rmeta, but I believe the logic for ignoring should be: "if the dir is excluded, but gets included because fd is ran inside of the ignored dir or is explicitly listed as a param, automatically enable the -I param`

    opened by nyurik 8
David Peter
David Peter
`cd` alternative. Navigate by typing abbreviation of paths.

kn /n/ kn is an alternative to cd. It lets you navigate quickly by typing abbreviations. It doesn't track frecency or any other statistics. WARNING: T

Mikołaj Powierża 65 Jul 22, 2022
A modern alternative to watch command

A modern alternative to watch command

Tavo Annus 4 Jul 10, 2022
Find RSA primes in files

RSA Prime Finder This program searches a file for RSA primes, i.e. primes P & Q, where P*Q == N. Usage: prime-finder 0.1 Calle Svensson <calle.svensso

Calle Svensson 13 May 15, 2022
A simple and fast download accelerator, written in Rust

zou A simple and fast download accelerator, written in Rust Zou is a Snatch fork by @k0pernicus. Snatch is a fast and interruptable download accelerat

Antonin Carette 172 Jul 23, 2022
A fast and minimalistic image viewer forked from the now discontinued emulsion.

Alloy Image viewer based on (now-discontinued) Emulsion. Alloy targets Windows, Mac, and Linux (with more targets to come!). A note for Linux users: W

Ardaku Systems 8 Jul 17, 2022
A fast duplicate file finder

The Directory Differential hTool DDH traverses input directories and their subdirectories. It also hashes files as needed and reports findings. The H

Jon Moroney 358 Sep 9, 2022
Blazing 💥 fast terminal-ui for git written in rust 🦀

Blazing fast terminal client for git written in Rust Features Fast and intuitive keyboard only control Context based help (no need to memorize tons of

Stephan Dilly 9k Sep 17, 2022
Super-fast command aliases with arguments.

Bonnie Bonnie is a command aliasing tool. If you have a super-long command that you have to run all the time, Bonnie is for you! Just define the comma

arctic_hen7 52 Sep 15, 2022
A simple rust-based tool for fetching system information

?? azf a simple rust-based tool for fetching system information you need a patched nerd font and the material design icons font ?? compiling you can c

Pedro Henrique 3 Sep 6, 2022
GTK application for browsing and installing fonts from Google's font archive

Font Finder This project is a from-scratch implementation of TypeCatcher in Rust. It is a GTK3 application for browsing through and installing fonts f

Michael Murphy 243 Sep 13, 2022
Linux Kernel Manager and Activity Monitor 🐧💻

Linux Kernel Manager and Activity Monitor ?? ?? The kernel is the part of the operating system that facilitates interactions between hardware and soft

Orhun Parmaksız 1.6k Sep 25, 2022
A project for automatically generating and maintaining Debian repositories from a TOML spec.

Debian Repository Builder A simple utility for constructing and maintaining Debian repositories. Configuration of a repo is based on the directory hie

Pop!_OS 52 Feb 7, 2022
Utility that takes logs from anywhere and sends them to Telegram.

logram Utility that takes logs from anywhere and sends them to Telegram. Supports log collection from files, journald and docker containers. More abou

Max Eliseev 82 Sep 20, 2022
Untrusted IPC with maximum performance and minimum latency. On Rust, on Linux.

Untrusted IPC with maximum performance and minimum latency. On Rust, on Linux. When is this Rust crate useful? Performance or latency is crucial, and

null 60 Aug 27, 2022
CLI utility to move (or rename) your files to a new location and redirect all of its symbolic links, to the new path

Move Links CLI utility to move (or rename) your files to a new location and redirect all of its symbolic links, to the new path (or name). Usage execu

Ben Mefteh 18 May 22, 2022
A tool to simplify reprovisioning a fresh OS. Installs packages and manages dotfiles.

[[TOC]] Comtrya This is better, yes? Warning This tool is ridiculously early in its development. I'm building out features as I migrate my dotfiles ov

David McKay 1 Aug 12, 2021
A tool to simplify reprovisioning a fresh OS. Installs packages and manages dotfiles.

Comtrya This is better, yes? Warning This tool is ridiculously early in its development. I'm building out features as I migrate my dotfiles over. Thos

Comtrya 245 Sep 12, 2022
Parallel finance a decentralized lending protocol built on top of the Polkadot ecosystem. Our unique approach will allow users to earn "double interests" from staking and lending their tokens simultaneously.

Parallel Finance A new Cumulus-based Substrate node, ready for hacking ?? Getting Started Follow these steps to get started with the Cumulus Template

parallel-finance 89 Sep 20, 2022
idf-env tool helps set up and manage ESP-IDF installations

idf-env Tool for maintaining ESP-IDF environment. Quick start Install serial drivers for ESP boards on Windows. Execute following command in PowerShel

Espressif Systems 20 Jun 1, 2022