🌸 A command-line fuzzy finder
Go to file
Junegunn Choi a4cf5510e3 0.9.11
2015-04-22 01:42:38 +09:00
bin [fzf-tmux/vim] Fixes for fish (#204) 2015-04-20 22:42:12 +09:00
man/man1 Add --inline-info option 2015-04-21 23:50:53 +09:00
plugin [fzf-tmux/vim] Fixes for fish (#204) 2015-04-20 22:42:12 +09:00
shell Fix broken FZF_TMUX switch and update test cases (#203) 2015-04-22 00:55:39 +09:00
src 0.9.11 2015-04-22 01:42:38 +09:00
test Update test cases for #203 2015-04-22 00:57:25 +09:00
.gitignore Rewrite fzf in Go 2015-01-04 00:37:29 +09:00
.travis.yml Fix Travis CI build 2015-04-15 01:58:39 +09:00
CHANGELOG.md 0.9.11 2015-04-22 01:42:38 +09:00
fzf 0.9.11 2015-04-22 01:42:38 +09:00
install 0.9.11 2015-04-22 01:42:38 +09:00
LICENSE Update install/build script from Homebrew 2015-01-14 00:02:37 +09:00
README.md [vim] README: Pointer to the wiki page 2015-04-15 22:52:15 +09:00
uninstall Refactor shell extensions 2015-03-13 17:41:00 +09:00

fzf - a command-line fuzzy finder travis-ci Flattr this

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

Pros

  • No dependency
  • Blazingly fast
    • e.g. locate / | fzf
  • Flexible layout
    • Runs in fullscreen or in horizontal/vertical split using tmux
  • The most comprehensive feature set
    • Try fzf --help and be surprised
  • Batteries included
    • Vim/Neovim plugin, key bindings and fuzzy auto-completion

Installation

fzf project consists of the followings:

  • 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 only)
  • Vim/Neovim plugin

You can download fzf executable alone, but it's recommended that you install the extra stuff using the attached install script.

Clone this repository and run install script.

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

Using curl

In case you don't have git installed:

mkdir -p ~/.fzf
curl -L https://github.com/junegunn/fzf/archive/master.tar.gz |
    tar xz --strip-components 1 -C ~/.fzf
~/.fzf/install

Using Homebrew

On OS X, you can use Homebrew to install fzf.

brew reinstall --HEAD fzf

# Install shell extensions
/usr/local/Cellar/fzf/HEAD/install

Install as Vim plugin

Once you have cloned the repository, add the following line to your .vimrc.

set rtp+=~/.fzf

Or you can have vim-plug manage fzf (recommended):

Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' }

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.

  • git: cd ~/.fzf && git pull && ./install
  • brew: brew reinstall --HEAD fzf
  • vim-plug: :PlugUpdate fzf

Usage

fzf will launch curses-based 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-J / CTRL-K (or CTRL-N / CTRL-P) 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

Extended-search mode

With -x or --extended option, fzf will start in "extended-search mode".

In this mode, you can specify multiple patterns delimited by spaces, such as: ^music .mp3$ sbtrkt !rmx

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

If you don't need fuzzy matching and do not wish to "quote" every word, start fzf with -e or --extended-exact option.

Examples

Many useful examples can be found on the wiki page. Feel free to add your own as well.

Key bindings for command line

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

  • CTRL-T - Paste the selected file path(s) into the command line
  • CTRL-R - Paste the selected command from history into the command line
    • Sort is disabled by default to respect chronological ordering
    • Press CTRL-R again to toggle sort
  • ALT-C - cd into the selected directory

If you're on a tmux session, CTRL-T will launch fzf in a new split-window. You may disable this tmux integration by setting FZF_TMUX to 0, or change the height of the window with FZF_TMUX_HEIGHT (e.g. 20, 50%).

If you use vi mode on bash, you need to add set -o vi before source ~/.fzf.bash in your .bashrc, so that it correctly sets up key bindings for vi mode.

If you want to customize the key bindings, consider editing the installer-generated source code: ~/.fzf.bash, ~/.fzf.zsh, and ~/.config/fish/functions/fzf_key_bindings.fish.

fzf-tmux script

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

# usage: fzf-tmux [-u|-d [HEIGHT[%]]] [-l|-r [WIDTH[%]]] [--] [FZF OPTIONS]
#        (-[udlr]: up/down/left/right)

# 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 -[udlr] options, so you can invariably use fzf-tmux in your scripts.

Fuzzy completion for bash

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]**<TAB>
# Files under 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 tab key after kill command.

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

Host names

For ssh and telnet commands, fuzzy completion for host names 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='+c -x'

Usage as Vim plugin

(Note: To use fzf in GVim, an external terminal emulator is required.)

:FZF[!]

If you have set up fzf for Vim, :FZF command will be added.

" Look for files under current directory
:FZF

" Look for files under your home directory
:FZF ~

" With options
:FZF --no-sort -m /tmp

" Bang version starts in fullscreen instead of using tmux pane or Neovim split
:FZF!

Similarly to ctrlp.vim, use enter key, CTRL-T, CTRL-X or CTRL-V to open selected files in the current window, in new tabs, in horizontal splits, or in vertical splits respectively.

Note that the environment variables FZF_DEFAULT_COMMAND and FZF_DEFAULT_OPTS also apply here. Refer to the wiki page for customization.

fzf#run([options])

For more advanced uses, you can call fzf#run() function which returns the list of the selected items.

fzf#run() may take an options-dictionary:

Option name Type Description
source string External command to generate input to fzf (e.g. find .)
source list Vim list as input to fzf
sink string Vim command to handle the selected item (e.g. e, tabe)
sink funcref Reference to function to process each selected item
sink* funcref Similar to sink, but takes the list of output lines at once
options string Options to fzf
dir string Working directory
up/down/left/right number/string Use tmux pane with the given size (e.g. 20, 50%)
window (Neovim only) string Command to open fzf window (e.g. vertical aboveleft 30new)
launcher string External terminal emulator to start fzf with (Only used in GVim)

However on Neovim fzf#run is asynchronous and does not return values so you should use sink or sink* to process the output from fzf.

Examples

If sink option is not given, fzf#run will simply return the list.

let items = fzf#run({ 'options': '-m +c', 'dir': '~', 'source': 'ls' })

But if sink is given as a string, the command will be executed for each selected item.

" Each selected item will be opened in a new tab
let items = fzf#run({ 'sink': 'tabe', 'options': '-m +c', 'dir': '~', 'source': 'ls' })

We can also use a Vim list as the source as follows:

" Choose a color scheme with fzf
nnoremap <silent> <Leader>C :call fzf#run({
\   'source':
\     map(split(globpath(&rtp, "colors/*.vim"), "\n"),
\         "substitute(fnamemodify(v:val, ':t'), '\\..\\{-}$', '', '')"),
\   'sink':     'colo',
\   'options':  '+m',
\   'left':     20,
\   'launcher': 'xterm -geometry 20x30 -e bash -ic %s'
\ })<CR>

sink option can be a function reference. The following example creates a handy mapping that selects an open buffer.

" List of buffers
function! s:buflist()
  redir => ls
  silent ls
  redir END
  return split(ls, '\n')
endfunction

function! s:bufopen(e)
  execute 'buffer' matchstr(a:e, '^[ 0-9]*')
endfunction

nnoremap <silent> <Leader><Enter> :call fzf#run({
\   'source':  reverse(<sid>buflist()),
\   'sink':    function('<sid>bufopen'),
\   'options': '+m',
\   'down':    len(<sid>buflist()) + 2
\ })<CR>

More examples can be found on the wiki page.

Articles

Tips

Rendering issues

If you have any rendering issues, check the followings:

  1. Make sure $TERM is correctly set. fzf will use 256-color only if it contains 256 (e.g. xterm-256color)
  2. If you're on screen or tmux, $TERM should be either screen or screen-256color
  3. Some terminal emulators (e.g. mintty) have problem displaying default background color and make some text unable to read. In that case, try --black option. And if it solves your problem, I recommend including it in FZF_DEFAULT_OPTS for further convenience.
  4. If you still have problem, try --no-256 option or even --no-color.

Respecting .gitignore, .hgignore, and svn:ignore

ag or pt will do the filtering:

# Feed the output of ag into fzf
ag -l -g "" | fzf

# Setting ag as the default source for fzf
export FZF_DEFAULT_COMMAND='ag -l -g ""'

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

git ls-tree for fast traversal

If you're running fzf in a large git repository, git ls-tree can boost up the speed of the traversal.

export FZF_DEFAULT_COMMAND='
  (git ls-tree -r --name-only HEAD ||
   find * -name ".*" -prune -o -type f -print -o -type l -print) 2> /dev/null'

Using fzf with tmux panes

The supplied fzf-tmux script should suffice in most of the cases, but if you want to be able to update command line like the default CTRL-T key binding, you'll have to use send-keys command of tmux. The following example will show you how it can be done.

# This is a helper function that splits the current pane to start the given
# command ($1) and sends its output back to the original pane with any number of
# optional keys (shift; $*).
fzf_tmux_helper() {
  [ -n "$TMUX_PANE" ] || return
  local cmd=$1
  shift
  tmux split-window -p 40 \
    "bash -c \"\$(tmux send-keys -t $TMUX_PANE \"\$(source ~/.fzf.bash; $cmd)\" $*)\""
}

# This is the function we are going to run in the split pane.
# - "find" to list the directories
# - "sed" will escape spaces in the paths.
# - "paste" will join the selected paths into a single line
fzf_tmux_dir() {
  fzf_tmux_helper \
    'find * -path "*/\.*" -prune -o -type d -print 2> /dev/null |
     fzf --multi |
     sed "s/ /\\\\ /g" |
     paste -sd" " -' Space
}

# Bind CTRL-X-CTRL-D to fzf_tmux_dir
bind '"\C-x\C-d": "$(fzf_tmux_dir)\e\C-e"'

Fish shell

It's a known bug of fish that it doesn't allow reading from STDIN in command substitution, which means simple vim (fzf) won't work as expected. The workaround is to store the result of fzf to a temporary file.

function vimf
  if fzf > $TMPDIR/fzf.result
    vim (cat $TMPDIR/fzf.result)
  end
end

function fe
  set tmp $TMPDIR/fzf.result
  fzf --query="$argv[1]" --select-1 --exit-0 > $tmp
  if [ (cat $tmp | wc -l) -gt 0 ]
    vim (cat $tmp)
  end
end

Handling UTF-8 NFD paths on OSX

Use iconv to convert NFD paths to NFC:

find . | iconv -f utf-8-mac -t utf8//ignore | fzf

License

MIT

Author

Junegunn Choi