Fzf - A command-line fuzzy finder

Related tags

Command-line vim go bash zsh tmux cli fish unix neovim fzf
Overview

fzf - a command-line fuzzy finder github-actions

fzf is a general-purpose command-line fuzzy finder.

It's an interactive Unix filter for command-line that can be used with any list; files, command history, processes, hostnames, bookmarks, git commits, etc.

Pros

  • Portable, no dependencies
  • Blazingly fast
  • The most comprehensive feature set
  • Flexible layout
  • Batteries included
    • Vim/Neovim plugin, key bindings, and fuzzy auto-completion

Table of Contents

Installation

fzf project consists of the following components:

  • fzf executable
  • fzf-tmux script for launching fzf in a tmux pane
  • Shell extensions
    • Key bindings (CTRL-T, CTRL-R, and ALT-C) (bash, zsh, fish)
    • Fuzzy auto-completion (bash, zsh)
  • Vim/Neovim plugin

You can download fzf executable alone if you don't need the extra stuff.

Using Homebrew

You can use Homebrew (on macOS or Linux) to install fzf.

brew install fzf

# To install useful key bindings and fuzzy completion:
$(brew --prefix)/opt/fzf/install

fzf is also available via MacPorts: sudo port install fzf

Using git

Alternatively, you can "git clone" this repository to any directory and run install script.

git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

Using Linux package managers

Package Manager Linux Distribution Command
APK Alpine Linux sudo apk add fzf
APT Debian 9+/Ubuntu 19.10+ sudo apt-get install fzf
Conda conda install -c conda-forge fzf
DNF Fedora sudo dnf install fzf
Nix NixOS, etc. nix-env -iA nixpkgs.fzf
Pacman Arch Linux sudo pacman -S fzf
pkg FreeBSD pkg install fzf
pkgin NetBSD pkgin install fzf
pkg_add OpenBSD pkg_add fzf
XBPS Void Linux sudo xbps-install -S fzf
Zypper openSUSE sudo zypper install fzf

⚠️ Key bindings (CTRL-T / CTRL-R / ALT-C) and fuzzy auto-completion may not be enabled by default.

Refer to the package documentation for more information. (e.g. apt-cache show fzf)

Packaging status

Windows

Pre-built binaries for Windows can be downloaded here. fzf is also available via Chocolatey and Scoop:

Package manager Command
Chocolatey choco install fzf
Scoop scoop install fzf

Known issues and limitations on Windows can be found on the wiki page.

As Vim plugin

If you use vim-plug, add this line to your Vim configuration file:

Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }

fzf#install() makes sure that you have the latest binary, but it's optional, so you can omit it if you use a plugin manager that doesn't support hooks.

For more installation options, see README-VIM.md.

Upgrading fzf

fzf is being actively developed, and you might want to upgrade it once in a while. Please follow the instruction below depending on the installation method used.

  • git: cd ~/.fzf && git pull && ./install
  • brew: brew update; brew upgrade fzf
  • macports: sudo port upgrade fzf
  • chocolatey: choco upgrade fzf
  • vim-plug: :PlugUpdate fzf

Building fzf

See BUILD.md.

Usage

fzf will launch interactive finder, read the list from STDIN, and write the selected item to STDOUT.

find * -type f | fzf > selected

Without STDIN pipe, fzf will use find command to fetch the list of files excluding hidden ones. (You can override the default command with FZF_DEFAULT_COMMAND)

vim $(fzf)

Using the finder

  • CTRL-K / CTRL-J (or CTRL-P / CTRL-N) to move cursor up and down
  • Enter key to select the item, CTRL-C / CTRL-G / ESC to exit
  • On multi-select mode (-m), TAB and Shift-TAB to mark multiple items
  • Emacs style key bindings
  • Mouse: scroll, click, double-click; shift-click and shift-scroll on multi-select mode

Layout

fzf by default starts in fullscreen mode, but you can make it start below the cursor with --height option.

vim $(fzf --height 40%)

Also, check out --reverse and --layout options if you prefer "top-down" layout instead of the default "bottom-up" layout.

vim $(fzf --height 40% --reverse)

You can add these options to $FZF_DEFAULT_OPTS so that they're applied by default. For example,

export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'

Search syntax

Unless otherwise specified, fzf starts in "extended-search mode" where you can type in multiple search terms delimited by spaces. e.g. ^music .mp3$ sbtrkt !fire

Token Match type Description
sbtrkt fuzzy-match Items that match sbtrkt
'wild exact-match (quoted) Items that include wild
^music prefix-exact-match Items that start with music
.mp3$ suffix-exact-match Items that end with .mp3
!fire inverse-exact-match Items that do not include fire
!^music inverse-prefix-exact-match Items that do not start with music
!.mp3$ inverse-suffix-exact-match Items that do not end with .mp3

If you don't prefer fuzzy matching and do not wish to "quote" every word, start fzf with -e or --exact option. Note that when --exact is set, '-prefix "unquotes" the term.

A single bar character term acts as an OR operator. For example, the following query matches entries that start with core and end with either go, rb, or py.

^core go$ | rb$ | py$

Environment variables

  • FZF_DEFAULT_COMMAND
    • Default command to use when input is tty
    • e.g. export FZF_DEFAULT_COMMAND='fd --type f'

    • ⚠️ This variable is not used by shell extensions due to the slight difference in requirements.

      (e.g. CTRL-T runs $FZF_CTRL_T_COMMAND instead, vim ** runs _fzf_compgen_path(), and cd ** runs _fzf_compgen_dir())

      The available options are described later in this document.

  • FZF_DEFAULT_OPTS
    • Default options
    • e.g. export FZF_DEFAULT_OPTS="--layout=reverse --inline-info"

Options

See the man page (man fzf) for the full list of options.

Demo

If you learn by watching videos, check out this screencast by @samoshkin to explore fzf features.

Examples

fzf-tmux script

fzf-tmux is a bash script that opens fzf in a tmux pane.

# usage: fzf-tmux [LAYOUT OPTIONS] [--] [FZF OPTIONS]

# See available options
fzf-tmux --help

# select git branches in horizontal split below (15 lines)
git branch | fzf-tmux -d 15

# select multiple words in vertical split on the left (20% of screen width)
cat /usr/share/dict/words | fzf-tmux -l 20% --multi --reverse

It will still work even when you're not on tmux, silently ignoring -[pudlr] options, so you can invariably use fzf-tmux in your scripts.

Alternatively, you can use --height HEIGHT[%] option not to start fzf in fullscreen mode.

fzf --height 40%

Key bindings for command-line

The install script will setup the following key bindings for bash, zsh, and fish.

  • CTRL-T - Paste the selected files and directories onto the command-line
    • Set FZF_CTRL_T_COMMAND to override the default command
    • Set FZF_CTRL_T_OPTS to pass additional options
  • CTRL-R - Paste the selected command from history onto the command-line
    • If you want to see the commands in chronological order, press CTRL-R again which toggles sorting by relevance
    • Set FZF_CTRL_R_OPTS to pass additional options
  • ALT-C - cd into the selected directory
    • Set FZF_ALT_C_COMMAND to override the default command
    • Set FZF_ALT_C_OPTS to pass additional options

If you're on a tmux session, you can start fzf in a tmux split-pane or in a tmux popup window by setting FZF_TMUX_OPTS (e.g. -d 40%). See fzf-tmux --help for available options.

More tips can be found on the wiki page.

Fuzzy completion for bash and zsh

Files and directories

Fuzzy completion for files and directories can be triggered if the word before the cursor ends with the trigger sequence, which is by default **.

  • COMMAND [DIRECTORY/][FUZZY_PATTERN]** 
# Files under the current directory
# - You can select multiple items with TAB key
vim **<TAB>

# Files under parent directory
vim ../**<TAB>

# Files under parent directory that match `fzf`
vim ../fzf**<TAB>

# Files under your home directory
vim ~/**<TAB>


# Directories under current directory (single-selection)
cd **<TAB>

# Directories under ~/github that match `fzf`
cd ~/github/fzf**<TAB>

Process IDs

Fuzzy completion for PIDs is provided for kill command. In this case, there is no trigger sequence; just press the tab key after the kill command.

# Can select multiple processes with 
   
     or 
    
      keys
    
   
kill -9 <TAB>

Host names

For ssh and telnet commands, fuzzy completion for hostnames is provided. The names are extracted from /etc/hosts and ~/.ssh/config.

ssh **<TAB>
telnet **<TAB>

Environment variables / Aliases

unset **<TAB>
export **<TAB>
unalias **<TAB>

Settings

# Use ~~ as the trigger sequence instead of the default **
export FZF_COMPLETION_TRIGGER='~~'

# Options to fzf command
export FZF_COMPLETION_OPTS='--border --info=inline'

# Use fd (https://github.com/sharkdp/fd) instead of the default find
# command for listing path candidates.
# - The first argument to the function ($1) is the base path to start traversal
# - See the source code (completion.{bash,zsh}) for the details.
_fzf_compgen_path() {
  fd --hidden --follow --exclude ".git" . "$1"
}

# Use fd to generate the list for directory completion
_fzf_compgen_dir() {
  fd --type d --hidden --follow --exclude ".git" . "$1"
}

# (EXPERIMENTAL) Advanced customization of fzf options via _fzf_comprun function
# - The first argument to the function is the name of the command.
# - You should make sure to pass the rest of the arguments to fzf.
_fzf_comprun() {
  local command=$1
  shift

  case "$command" in
    cd)           fzf "$@" --preview 'tree -C {} | head -200' ;;
    export|unset) fzf "$@" --preview "eval 'echo \$'{}" ;;
    ssh)          fzf "$@" --preview 'dig {}' ;;
    *)            fzf "$@" ;;
  esac
}

Supported commands

On bash, fuzzy completion is enabled only for a predefined set of commands (complete | grep _fzf to see the list). But you can enable it for other commands as well by using _fzf_setup_completion helper function.

# usage: _fzf_setup_completion path|dir|var|alias|host COMMANDS...
_fzf_setup_completion path ag git kubectl
_fzf_setup_completion dir tree

Custom fuzzy completion

(Custom completion API is experimental and subject to change)

For a command named "COMMAND", define _fzf_complete_COMMAND function using _fzf_complete helper.

_fzf_complete_doge() { _fzf_complete --multi --reverse --prompt="doge> " -- "$@" < <( echo very echo wow echo such echo doge ) } "> 
# Custom fuzzy completion for "doge" command
#   e.g. doge **
   
_fzf_complete_doge() {
  _fzf_complete --multi --reverse --prompt="doge> " -- "$@" < <(
    echo very
    echo wow
    echo such
    echo doge
  )
}
  • The arguments before -- are the options to fzf.
  • After --, simply pass the original completion arguments unchanged ("$@").
  • Then, write a set of commands that generates the completion candidates and feed its output to the function using process substitution (< <(...)).

zsh will automatically pick up the function using the naming convention but in bash you have to manually associate the function with the command using the complete command.

[ -n "$BASH" ] && complete -F _fzf_complete_doge -o default -o bashdefault doge

If you need to post-process the output from fzf, define _fzf_complete_COMMAND_post as follows.

_fzf_complete_foo() {
  _fzf_complete --multi --reverse --header-lines=3 -- "$@" < <(
    ls -al
  )
}

_fzf_complete_foo_post() {
  awk '{print $NF}'
}

[ -n "$BASH" ] && complete -F _fzf_complete_foo -o default -o bashdefault foo

Vim plugin

See README-VIM.md.

Advanced topics

Performance

fzf is fast and is getting even faster. Performance should not be a problem in most use cases. However, you might want to be aware of the options that affect performance.

  • --ansi tells fzf to extract and parse ANSI color codes in the input, and it makes the initial scanning slower. So it's not recommended that you add it to your $FZF_DEFAULT_OPTS.
  • --nth makes fzf slower because it has to tokenize each line.
  • --with-nth makes fzf slower as fzf has to tokenize and reassemble each line.
  • If you absolutely need better performance, you can consider using --algo=v1 (the default being v2) to make fzf use a faster greedy algorithm. However, this algorithm is not guaranteed to find the optimal ordering of the matches and is not recommended.

Executing external programs

You can set up key bindings for starting external processes without leaving fzf (execute, execute-silent).

# Press F1 to open the file with less without leaving fzf
# Press CTRL-Y to copy the line to clipboard and aborts fzf (requires pbcopy)
fzf --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort'

See KEY BINDINGS section of the man page for details.

Reloading the candidate list

By binding reload action to a key or an event, you can make fzf dynamically reload the candidate list. See https://github.com/junegunn/fzf/issues/1750 for more details.

1. Update the list of processes by pressing CTRL-R

FZF_DEFAULT_COMMAND='ps -ef' \
  fzf --bind 'ctrl-r:reload($FZF_DEFAULT_COMMAND)' \
      --header 'Press CTRL-R to reload' --header-lines=1 \
      --height=50% --layout=reverse

2. Switch between sources by pressing CTRL-D or CTRL-F

FZF_DEFAULT_COMMAND='find . -type f' \
  fzf --bind 'ctrl-d:reload(find . -type d),ctrl-f:reload($FZF_DEFAULT_COMMAND)' \
      --height=50% --layout=reverse

3. Interactive ripgrep integration

The following example uses fzf as the selector interface for ripgrep. We bound reload action to change event, so every time you type on fzf, the ripgrep process will restart with the updated query string denoted by the placeholder expression {q}. Also, note that we used --disabled option so that fzf doesn't perform any secondary filtering.

INITIAL_QUERY=""
RG_PREFIX="rg --column --line-number --no-heading --color=always --smart-case "
FZF_DEFAULT_COMMAND="$RG_PREFIX '$INITIAL_QUERY'" \
  fzf --bind "change:reload:$RG_PREFIX {q} || true" \
      --ansi --disabled --query "$INITIAL_QUERY" \
      --height=50% --layout=reverse

If ripgrep doesn't find any matches, it will exit with a non-zero exit status, and fzf will warn you about it. To suppress the warning message, we added || true to the command, so that it always exits with 0.

Preview window

When the --preview option is set, fzf automatically starts an external process with the current line as the argument and shows the result in the split window. Your $SHELL is used to execute the command with $SHELL -c COMMAND. The window can be scrolled using the mouse or custom key bindings.

# {} is replaced with the single-quoted string of the focused line
fzf --preview 'cat {}'

Preview window supports ANSI colors, so you can use any program that syntax-highlights the content of a file, such as Bat or Highlight:

fzf --preview 'bat --style=numbers --color=always --line-range :500 {}'

You can customize the size, position, and border of the preview window using --preview-window option, and the foreground and background color of it with --color option. For example,

fzf --height 40% --layout reverse --info inline --border \
    --preview 'file {}' --preview-window up,1,border-horizontal \
    --color 'fg:#bbccdd,fg+:#ddeeff,bg:#334455,preview-bg:#223344,border:#778899'

See the man page (man fzf) for the full list of options.

For more advanced examples, see Key bindings for git with fzf (code).

Since fzf is a general-purpose text filter rather than a file finder, it is not a good idea to add --preview option to your $FZF_DEFAULT_OPTS.

# *********************
# ** DO NOT DO THIS! **
# *********************
export FZF_DEFAULT_OPTS='--preview "bat --style=numbers --color=always --line-range :500 {}"'

# bat doesn't work with any input other than the list of files
ps -ef | fzf
seq 100 | fzf
history | fzf

Tips

Respecting .gitignore

You can use fd, ripgrep, or the silver searcher instead of the default find command to traverse the file system while respecting .gitignore.

# Feed the output of fd into fzf
fd --type f | fzf

# Setting fd as the default source for fzf
export FZF_DEFAULT_COMMAND='fd --type f'

# Now fzf (w/o pipe) will use fd instead of find
fzf

# To apply the command to CTRL-T as well
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

If you want the command to follow symbolic links and don't want it to exclude hidden files, use the following command:

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

Fish shell

CTRL-T key binding of fish, unlike those of bash and zsh, will use the last token on the command-line as the root directory for the recursive search. For instance, hitting CTRL-T at the end of the following command-line

ls /var/

will list all files and directories under /var/.

When using a custom FZF_CTRL_T_COMMAND, use the unexpanded $dir variable to make use of this feature. $dir defaults to . when the last token is not a valid directory. Example:

/dev/null | sed '1d; s#^\./##'" "> 
set -g FZF_CTRL_T_COMMAND "command find -L \$dir -type f 2> /dev/null | sed '1d; s#^\./##'"

Related projects

https://github.com/junegunn/fzf/wiki/Related-projects

License

The MIT License (MIT)

Copyright (c) 2013-2021 Junegunn Choi

Comments
  • [Ubuntu] --preview error : Failed to read /dev/tty

    [Ubuntu] --preview error : Failed to read /dev/tty

    • Category
      • [x ] fzf binary
      • [ ] fzf-tmux script
      • [ ] Key bindings
      • [ ] Completion
      • [ ] Vim
      • [ ] Neovim
      • [ ] Etc.
    • OS
      • [x ] Linux
      • [ ] Mac OS X
      • [ ] Windows
      • [ ] Windows Subsystem for Linux
      • [ ] Etc.
    • Shell
      • [ x] bash
      • [ ] zsh
      • [ ] fish

    When I use --preview I got the error message: Failed to read /dev/tty

    $ echo "hello" | fzf
hello
$ echo "hello" | fzf --preview 'echo {}'
Failed to read /dev/tty
$ echo $TERM
xterm-256color
$ tty
/dev/pts/6
$ fzf --version
0.17.5 (b46227d)
$ lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 18.04.1 LTS
Release:	18.04
Codename:	bionic
    opened by erch 70
  • fzf on gvim windows without WSL?

    fzf on gvim windows without WSL?

    • Category
      • [] fzf binary
      • [ ] fzf-tmux script
      • [ ] Key bindings
      • [ ] Completion
      • [x] Vim
      • [ ] Neovim
      • [ ] Etc.
    • OS
      • [ ] Linux
      • [ ] Mac OS X
      • [x] Windows
      • [ ] Windows Subsystem for Linux
      • [ ] Etc.
    • Shell
      • [ ] bash
      • [ ] zsh
      • [ ] fish

    I'm not sure that fzf can run without a shell yet. But if possible, please add this feature, the only thing that I can't try fzf on my windows is I don't have a shell except cmd.exe.

    question windows 
    opened by ghost 66
  • [neovim] :FZF sometimes fails to open certain files

    [neovim] :FZF sometimes fails to open certain files

    Sometimes when I :FZF, select a file, and then press <Enter>, NeoVim becomes unresponsive.

    When this happens, pressing <Enter> a couple more times brings up the following:

    W10: Warning: Changing a readonly file
E315: ml_get: invalid lnum: 570
Press ENTER or type command to continue
E315: ml_get: invalid lnum: 568
Press ENTER or type command to continue
E315: ml_get: invalid lnum: 403
Press ENTER or type command to continue
...

    Interestingly, opening the same file in a split (via <C-v>) seems to work, although nothing happens until I press <Enter> one extra time... i.e. <C-v> nothing happens <Enter> buffer opens as expected.

    Quitting & relaunching NeoVim seems to make the problem go away for a while, so it's difficult to reproduce.

    neovim 
    opened by adambiggs 48
  • Neovim compatibility

    Neovim compatibility

    https://github.com/neovim/neovim/issues/1477

    :confused:

    Vim plugin of fzf relies on :! for running fzf when not on tmux, and Neovim currently does not (and probably will not) support running interactive programs using :!.

    enhancement 
    opened by junegunn 48
  • cd tab completion not working

    cd tab completion not working

    • Category
      • [ ] fzf binary
      • [ ] fzf-tmux script
      • [ ] Key bindings
      • [x] Completion
      • [ ] Vim
      • [ ] Neovim
      • [ ] Etc.
    • OS
      • [x] Linux
      • [ ] Mac OS X
      • [ ] Windows
      • [ ] Windows Subsystem for Linux
      • [ ] Etc.
    • Shell
      • [x] bash
      • [ ] zsh
      • [ ] fish

    For some reason, cd <tab> is not auto-complete for me. I am running on a linux terminal X11-forwarded to a Windows machine.

    fzf version is 0.16.6.

    I have narrowed down the problem to these lines in shell/completion.bash:

    # Directory
for cmd in $d_cmds; do
  _fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o plusdirs"
done

    Commenting them out gives me back the regular tab autocompletion behavior.

    Please let me know if there's some way I could debug this further.

    help-needed not-reproducible 
    opened by tnguyen14 43
  • Option to preview focused item with an external command

    Option to preview focused item with an external command

    Something like:

    git ls-files | fzf --preview "head -$LINES {}" --color light --margin 5,20
    head

    With some ANSI colors:

    git ls-files | fzf --preview "pygmentize {}" --color light --margin 5,20
    pygmentize

    TBD:

    • Yes or no
    • Layout: top/bottom/left/right(/hidden), size
    feature 
    opened by junegunn 38
  • Use the terminal by default for nvim-0.2.1 or GVim (nightly)

    Use the terminal by default for nvim-0.2.1 or GVim (nightly)

    Initial work to use the neovim terminal by default in Windows. The double keypress remains for Windows 8+ because https://github.com/gdamore/tcell/pull/159 is unresolved.

    I prefer to keep this open/unmerged until the 0.2.1 release while I test this with my pull requests in fzf.vim.

    @mikesmiffy128 I cherry-pick the commit as you suggested in https://github.com/junegunn/fzf/pull/962#issuecomment-322936545

    neovim windows 
    opened by janlazo 35
  • Fix ExecCommandWith for cmd.exe in Windows

    Fix ExecCommandWith for cmd.exe in Windows

    Close #1018

    Run the command as is in cmd.exe with no parsing and escaping. Explicity set cmd.SysProcAttr so execCommand does not escape the command. Technically, the command should be escaped with ^ for special characters, including ". This allows cmd.exe commands to be chained together.

    See https://github.com/neovim/neovim/pull/7343#issuecomment-333350201

    However, this requires a new shellescape function that is specific to one of the following:

    • interactive prompt
    • batchfile
    • command name

    fzf#shellescape in the Vim plugin can handle only the batchfile.

    enhancement windows 
    opened by janlazo 34
  • Feature Request: Option to hide some fields

    Feature Request: Option to hide some fields

    The request

    I would like to somehow be able to dissociate what is shown to what is returned. For example, the output of git --no-pager log --format=oneline --abbrev-commit -n 5 in this repository

    6fd6fff [vim] Ignore 'dir' option if empty
d1387bf Use IO.console when possible
4c923a2 [uninstall] Remove both patterns of source command (#97)
4ee85f1 [install] Join line numbers when multiple matches found
829c7f9 Merge branch 'mjwhitta-master'

    I'd like to be able to show only the commit messages, without the sha, but at the same time, when I choose one, I want the sha to be in the output. So fzf would show me this:

    [vim] Ignore 'dir' option if empty
Use IO.console when possible
[uninstall] Remove both patterns of source command (#97)
[install] Join line numbers when multiple matches found
Merge branch 'mjwhitta-master'

    And when I choose the last one, I get this, the full line:

    829c7f9 Merge branch 'mjwhitta-master'

    Possible interface

    The interface could, for example, be similar to that for limiting the search scope. Only in this case we either choose what to hide, or what to show.

    feature 
    opened by jdevera 33
  • Support cygwin vim via cygpath and Windows binary

    Support cygwin vim via cygpath and Windows binary

    Since cygwin sh/bash runs cmd.exe in the back (sh/bash by itself is run in a cmd.exe terminal) and use TERM=cygwin, we can run cygwin vim and the fzf (Windows) binary in cmd.exe/powershell. Benefit of including cygwin support to the vim plugin is running the tests as is in Windows. I'm currently using this for the Vader tests.

    By unsetting TERM, fzf runs as if vim (Windows) is used. cygpath (via s:cygpath) is used for path conversion between Windows and cygwin filepaths. I updated s:escape to escape () for Windows filepaths.

    Currently, this PR does not support mintty (TERM=xterm) because fzf is run inline (no shell script or batchfile) and I can't get the start command to work with shell redirection yet. Neovim TUI in cygwin sh/bash is not supported in the vim plugin even though it runs fine (without mintty) in sh/bash. I'll work on that along with :terminal when 0.2.1 is released.

    I'm using the cygwin environment from Git For Windows and tested this PR in sh.exe with TERM=cygwin.

    windows 
    opened by janlazo 32
  • [Question] Can you tell me the test files?

    [Question] Can you tell me the test files?

    https://raw.githubusercontent.com/junegunn/i/master/fzf-commandt-ctrlp-unite.gif

    I read the page and found unite.vim cache performance was too bad. But I have improved file_rec/async performance in unite.vim.

    I want to re-test for the files.

    question 
    opened by Shougo 32
  • How to selectively disable Ctrl+R shell keybinding (while NOT disabling Alt+C & others)

    How to selectively disable Ctrl+R shell keybinding (while NOT disabling Alt+C & others)

    • [x] I have read through the manual page (man fzf)
    • [x] I have the latest version of fzf (0.35.1 a38b63b)
    • [x] I have searched through the existing issues

    Info

    • OS: Linux
    • Shell: fish 3.6.0

    Problem / Steps to reproduce

    Version 3.6.0 of the Fish shell, released today, ships a default searchable Ctrl+R shell key binding: https://github.com/fish-shell/fish-shell/issues/602 . It does a great job, and because it's specialized to fish, it does a few nice things, in particular, syntax highlighting.

    So, I'd like to migrate from fzf Ctrl+R shell keybinding to it...

    ... but I also want to keep being able to use fzf's Alt+C ! I want to only disable fzf's Ctrl+R shell keybinding but I do not want to disable fzf's Alt+C.

    → How can I selectively disable fzf's Ctrl+R shell keybinding while keeping fzf's Alt+C keybinding working? So far my attempt was to no longer call fzf_key_bindings in my fish config, but of couse it disables all keybindings 😕. Is there more granular configuration?

    Thanks for the help and thanks for fzf!

    opened by ronjouch 0
  • [Feature] Action to change `--nth` and `--with-nth` dynamically

    [Feature] Action to change `--nth` and `--with-nth` dynamically

    • [x] I have read through the manual page (man fzf)
    • [x] I have the latest version of fzf
    • [x] I have searched through the existing issues

    Info

    • OS
      • [x] Linux
      • [x] Mac OS X
      • [x] Windows
      • [x] Etc.
    • Shell
      • [x] bash
      • [x] zsh
      • [x] fish

    Problem / Steps to reproduce

    Add action to change nth and with-nth value during runtime similar to change-prompt action

    Sample use case: grep -n . dir1 dir2 dir2 | fzf --delimiter : --with-nth=3.. --preview "cat {1}"

    • This displays only the text lines from file (Prefer this most of the time as displaying the filepath and line number makes it more crowded to fit in the screen).
    • --with-nth=1.. If I can bind a shortcut to toggle with-nth value during runtime, it would be very useful to see the file path as well.
    opened by cibinmathew 7
  • Using a Fish function in --preview fails with `/bin/sh : 1: __my_fn not found`

    Using a Fish function in --preview fails with `/bin/sh : 1: __my_fn not found`

    • [x] I have read through the manual page (man fzf)
    • [x] I have the latest version of fzf
    • [x] I have searched through the existing issues

    Info

    • OS
      • [x] Linux
      • [ ] Mac OS X
      • [ ] Windows
      • [ ] Etc.
    • Shell
      • [ ] bash
      • [ ] zsh
      • [x] fish

    Problem / Steps to reproduce

    Fzf is somehow not able to execute my fish function when adding it to the preview command. Screenshot from 2022-12-25 09-19-36

    opened by marko911 1
  • FZF reverse search key binding does not work on Linux Mint 21

    FZF reverse search key binding does not work on Linux Mint 21

    • [x] I have read through the manual page (man fzf)
    • [x] I have the latest version of fzf
    • [x] I have searched through the existing issues

    Info

    • OS
      • [x] Linux
      • [ ] Mac OS X
      • [ ] Windows
      • [ ] Etc.
    • Shell
      • [ ] bash
      • [x] zsh
      • [ ] fish

    Problem / Steps to reproduce

    Clean install using sudo apt-get install fzf then adding source /usr/share/doc/fzf/examples/key-bindings.zsh to my zshrc

    ctrl t works ctrl r does not

    opened by wellsjo 0
  • View non-whitespace special characters as word boundaries

    View non-whitespace special characters as word boundaries

    • [x] I have read through the manual page (man fzf)
    • [x] I have the latest version of fzf
    • [x] I have searched through the existing issues

    Info

    • OS
      • [x] Linux
      • [ ] Mac OS X
      • [ ] Windows
      • [ ] Etc.
    • Shell
      • [ ] bash
      • [z] zsh
      • [ ] fish

    Problem / Steps to reproduce

    image

    I am not quite sure about this, but I think I'd like to be <> and other non-alphanumeric characters to be treated as or similar to spaces, thus that the above, shorter matches would be prioritised higher. Also, it might be worth considering repeated matches.

    opened by xeruf 0
Releases(0.35.1)
Owner
Junegunn Choi
Junegunn Choi
GitHub
Integrate Mcfly with fzf to combine a solid command history database with a widely-loved fuzzy search UI

McFly fzf integration Integrate McFly with fzf to combine a solid command history database with a widely-loved fuzzy search UI Features: Advanced hist

null 11 Jan 25, 2023
Skim - Fuzzy Finder in rust!

Life is short, skim! Half of our life is spent on navigation: files, lines, commands… You need skim! It is a general fuzzy finder that saves you time.

Takayuki Maeda 0 May 16, 2021
A simple, modern fuzzy finder tool to run examples in a Cargo project.

cargo-rx cargo-rx is a simple, modern Runner for Examples in a Cargo project. This crate provides a single executable: rx. Basically anywhere you woul

Ritvik Nag 14 Dec 2, 2022
interactcli-rs is a command-line program framework used to solve the problem of the integration of command-line and interactive modes, including functions such as unification of command-line interactive modes and sub-command prompts. The framework integrates clap and shellwords.

interactcli-rs 简体中文 interactcli-rs is a command-line program framework used to solve the problem of the integration of command-line and interactive mo

JiaShiwen 12 Nov 5, 2022
A hackable, minimal, fast TUI file explorer, stealing ideas from nnn and fzf.

xplr A hackable, minimal, fast TUI file explorer, stealing ideas from nnn and fzf. [Quickstart] [Features] [Plugins] [Documentation] [Upgrade Guide] [

Arijit Basu 2.6k Jan 1, 2023
🧠 A command-line utility for switching git branches more easily. Switch branches interactively or use a fuzzy search to find that long-forgotten branch name.

git-smart-checkout A git command extension for switching git branches more efficiently. About Interactively switch branches or fuzzy search for that f

Cezar Craciun 51 Dec 29, 2022
Small command-line tool to switch monitor inputs from command line

swmon Small command-line tool to switch monitor inputs from command line Installation git clone https://github.com/cr1901/swmon cargo install --path .

William D. Jones 5 Aug 20, 2022
Save cli commands and fuzzy find them later

crow - cli command memorizer What is crow? | Installation | Usage | FAQ What is crow? crow (command row) is a CLI tool to help you memorize CLI comman

sandstorm 7 Feb 17, 2022
Fuzzy Index for Python, written in Rust. Works like error-tolerant dict, keyed by a human input.

FuzzDex FuzzDex is a fast Python library, written in Rust. It implements an in-memory fuzzy index that works like an error-tolerant dictionary keyed b

Tomasz bla Fortuna 8 Dec 15, 2022
A multi-page fuzzy launcher for your terminal, written in Rust.

fr33zmenu A multi-page fuzzy launcher for your terminal, written in Rust. Supports theming and multiple keybind schemes, including basic vim keybinds.

null 3 Dec 15, 2022
Fast TLSH-compatible Fuzzy Hashing Library in pure Rust

fast-tlsh: Fast TLSH-compatible Fuzzy Hashing Library in pure Rust TLSH stands for Trendmicro Locality Sensitive Hash. TLSH can be used to detect simi

Tsukasa OI 4 Mar 27, 2024
Command-line HTTP client for sending a POST request to specified URI on each stdin line.

line2httppost Simple tool to read lines from stdin and post each line as separate POST request to a specified URL (TCP connection is reused though). G

Vitaly Shukela 3 Jan 3, 2023
Pink is a command-line tool inspired by the Unix man command.

Pink is a command-line tool inspired by the Unix man command. It displays custom-formatted text pages in the terminal using a subset of HTML-like tags.

null 3 Nov 2, 2023
Checkline: checkbox line picker for stdin line input

checkline is a Unix command line interface (CLI) terminal user interface (TUI) that prompts you to check each line of stdin, to pick each line to output to stdout

SixArm 4 Dec 4, 2022
A full featured, fast Command Line Argument Parser for Rust

clap Command Line Argument Parser for Rust It is a simple-to-use, efficient, and full-featured library for parsing command line arguments and subcomma

null 10.4k Jan 10, 2023
Docopt for Rust (command line argument parser).

THIS CRATE IS UNMAINTAINED This crate is unlikely to see significant future evolution. The primary reason to choose this crate for a new project is if

null 743 Jan 1, 2023
Parse command line arguments by defining a struct.

StructOpt Parse command line arguments by defining a struct. It combines clap with custom derive. Documentation Find it on Docs.rs. You can also check

Guillaume P. 2.6k Jan 5, 2023
A command line progress reporting library for Rust

indicatif Documentation A Rust library for indicating progress in command line applications to users. This currently primarily provides progress bars

Armin Ronacher 3.2k Dec 30, 2022
Low-level Rust library for implementing terminal command line interface, like in embedded systems.

Terminal CLI Need to build an interactive command prompt, with commands, properties and with full autocomplete? This is for you. Example, output only

HashMismatch 47 Nov 25, 2022