Improving Shell Workflows with Fzf

I use fzf in this very way and could have written this article if I weren’t lazy lol. However, I can add two other use cases:

1. I use i3wm at home (haven’t yet made the jump into Sway/Wayland), and don’t want to change my screen resolution by opening an app, clicking with my mouse, and then waiting. So I use fzf for quick resolution changes using xrandr:

  cr() {
    xrandr | sed -En “s/^[ ]+([0-9]{3,4}x[0-9]{3,4}0.\*/\1/p” | fzf | xargs -I{} xrandr —output HDMI-0 —mode {}
  }

2. At work I switch between multiple Kubernetes contexts during the day. To make the switch fast without typing a sentence, I will use this helper function:

  kc () {
     kubectl config get-contexts | tail -n +2 | fzf | cut -c 2- | awk ‘{print $1}’ | xargs kubectl config use-context
  }

I found this to be better than tab-completion because with tab completion I only get the name of the context, and not the cluster/user/namespace fields that make it easier to select the right one.

Use the above at your own risk, as they are fast hack-ups and could be far more clear (my sed skills are prone to error and overly verbose).

—Edited for HN formatting

Those are very creative use cases for fzf, I had never considered doing something like that.

My usage of it probably counts as quite basic. That said, I use it constantly. I just love the feeling of real time interaction it gives - it is well and truly part of my muscle memory now.

I use the vim plugin too, which is also brilliant and makes navigating larger projects very quick and easy. I use these two extra bindings all the time:

  nnoremap <silent> <C-Space> yiw:Rg <C-r>"<CR>
  vnoremap <silent> <C-Space> y:Rg <C-r>"<CR>

They're very simple, but when combined with the ability to add search items to the quickfix list it makes for a pretty powerful workflow.

The first one in particular gives a great approximation of symbol search that 'just works' anywhere.

Junegunn, the fzf author, makes great vim plugins too. Both the user experience and the developer experience (the code of these plugins) feel just right.

Fzf is better integrated in vim than in emacs. So I use dmenu on X/wofi on wayland instead, which are basically GUI fzf replacement.

I love fzf and tend to use it whenever repeatitive, non-static behavior is in play.

Replacing Ctrl-R with fzf is the most basic and most useful usage.

Basically every git command involving history, branches etc have fzf wrappers in my setup.

My latest, least common usage is having built a wrapper around KeepassX and keepassx-cli to access my secrets from the CLI with fzf to fuzzy search entries. Saves me a lot of time every day.

Thanks junegunn for theamazimg tool!

Alternatively, you can add fzf to the <TAB> menu and have it available anywhere that you have tab-completion: https://github.com/Aloxaf/fzf-tab

(I use this and it works great.)

I mostly use it to open files in vim [0]. The good thing about these aliases is that they keep the command in the shell history. So you open a file with the alias and it will leave a full 'vim path-to-file' in the history.

  # Open any file under current dir
  vf() {
    files="$(fzf --query="$1" --multi --select-1 --exit-0)"
    if test -n "$files"; then
        echo "${EDITOR:-vim} \"$files\""
        print -s "${EDITOR:-vim} \"$files\""
        ${EDITOR:-vim} "$files"
    fi
  }
  
  # Open from current modified files in git repository
  vfc() {
    files="$(git ls-files -m | fzf --multi --select-1 --exit-0)"
    if test -n "$files"; then
        echo "${EDITOR:-vim} \"$files\""
        print -s "${EDITOR:-vim} \"$files\""
        ${EDITOR:-vim} "$files"
    fi
  }

I also have a "create feature branch from JIRA issue" (it was in the list of ideas in this post I wrote for the engineering blog at work [1] about autocompleting EC2 instances, although I was already using it). The JIRA API is a bit too slow for fast response, so what I do is populate a text file via a cron job that requests from the API regularly, and use the text in the file for the completion.

    [1]: https://engineering.hybridtheory.com/aws/devops/2018/08/15/fzf-autocompletions/

If anyone is interested in a rust version (probably the main benefit being you can use it as a rust library) there is a similar tool called skim[1]

It's actively developed and seems to have a non-overlapping set of features with fzf other than the basics (they both have features the other doesn't, and skim copies most of the core ui from fzf)

[1] https://github.com/lotabout/skim

Fzf can be a tremendous time-sink because its credible promise to improve your quality of life in the terminal.

One of my most-frequently-used pry customizations is a keybinding that opens the current backtrace in fzf, with the preview window showing the selected location, allowing me to quickly walk up or down the stack, with tons of context. `enter` takes me to that frame, and `ctrl-v` opens that file location in vim.

Fzf is great, but unfortunately it doesn't have line wrap (there's an open bug basically marked as WONTFIX). So if you frequently work with long commands and want to use fzf to search for older commands with Ctrl-R, things will be quite complicated :-(

I think the first example should have been done with direnv rather than having a manual step, but I supposed to each their own. The other examples are all pretty neat.

I recently set up fasd, which I recommend, but I tied it together with fzf, which makes it really nice.

fasd: https://github.com/clvv/fasd

tie it with fzf: https://github.com/CGamesPlay/dotfiles/blob/master/files/.co...

Here's a way to search and watch Youtube without ads, using fzf, youtube-dl, mpv, and jq:

    mpv ytdl://$(youtube-dl -j 'ytsearch30:spider pig' | jq '{id,title,uploader}' --compact-output | fzf | jq -r .id)

My only constant usage pattern for this is integration with 10000 last unique lines of Redis stored history across all the systems I use. Push every unique command into a single Redis across all the systems, Ctrl-R to pull it via fzf. It really improves command line performance.

fzf is also great as a live preview window for a command:

    echo '' | fzf --print-query --preview-window wrap --preview 'cat test.json | jql {q}'

Here shown with jql[0] to write json queries and see the live output.

[0]: https://github.com/cube2222/jql

After fiddling with Emacs, I have a persistent thought that the shell would benefit considerably from more featureful completion in the style of Helm/Ivy, instead of just a list with an occasional ‘preview’. The shell is a programming environment, after all, with all the commands and executables being the library—so we need to finally treat it as such.

For starters, I want the completion to show the arguments order for a command, and one-line description for each option. Perhaps my completion config is just incomplete, but somehow I haven't seen any howtos of this scale yet.

Figure I'd link my git aliases here, that make heavy use of fzf. The goal is generally to never have to type a filename (eg. for git add) or a commit hash (eg. for cherry-pick).

Here's a link to my 'cp' alias that lets me choose a branch, then a commit to cherry pick into my current branch:

https://github.com/kbd/setup/blob/e23b3e8e2363284c3c766c0be2...

I have, after some extreme madness, slightly adapted (and I dare say improved) the github checkout one. My use case is to check out PRs that have had my review requested, so I changed the JQ command to do that (which you may or may not want), but the real masterstroke was adding in previewing the body of the PR with mdv. Key to doing that was switching to null delimited lines.

    gh api 'repos/:owner/:repo/pulls' |\
    jq -c --raw-output -j '[ .[] | select( .requested_reviewers | select(.[].login | contains("your-github-handle-here"))) ] | .[] | "#\(.number)\u0009\(.title)\u0009\(.body)\u0000"' |\
    fzf --read0 --delimiter='\t' --with-nth=1,2 --preview='echo {3} | mdv -' --preview-window=up:80% |\
    sed -n '1s/#\([0-9]\+\).*/\1/p' |\
    xargs gh pr checkout

I did my damnedest to use the unit separator character 0x1F instead of tab in between fields but I could not figure out how to get FZF to like it. It makes me so sad that those characters with absolutely primo spots in the ASCII table and that ACTUALLY MEAN what we use tabs (or commas, or pipes) and linebreaks for don't get any love. Ah well.

These are great.

I'll throw in a fifth, which is I've slowly been cobbling together a simple fuzzy CLI music player (though I use fzy rather than fzf but same idea).

Code is here: https://github.com/Julian/dotfiles/tree/main/.config/zsh/fun...

Look at say `artist` or `play` or `shuffle` which are the music ones.

I concur.

I saw this tool to find pytest cases after I implemented my own simple fzf shell function that uses bat for preview. https://github.com/dbaty/testfinder

I also implemented simple bash functions to:

+ Select a CMake target to build

Extract all add_executables defined in the CMakeLists of my project directory and pipe the fzf selection to cmake to build

+ Find and sort (by mtime) all compiled executables placed in the cmake build directory

It can be hard to remember the path of the executable produced by cmake, so i find all executable files in the cmake build dir, ls -alh, sort them by mtime (you want to execute the most recently compiled binary) and pipe to fzf

Any time I pipe something to grep, I think if this could become an fzf-based command. Highly recommend people do the same with their workflows.

I just switched my time tracking to a fzf-based solution named tmt [1], also a great use case for fzf!

[1] https://github.com/sitaramc/notes/blob/master/tmt

If you use vim, I created this plugin to manage branches using fzf https://github.com/stsewd/fzf-checkout.vim

Nice, I love fzf! It’s an amazing recursive search replacement, but my favorite use was a script I wrote for changing git branches, where they were sorted by most recently changed so that the branch you’re probably looking for is only a few lines away, but you can go back pretty far too if you want. It feels like tig but for changing branches, it’s awesome.

Some excellent scripts, I like the one with `--multi` to delete git branches.

My most powerful bash alias has become this one [1], where `subl` is the editor of my choice. I no longer search files, I find them. Really, fzf is almost indistinguishable from magic and has become crucial to my workflow.

[1] alias fzubl='fzf -m | xargs subl'

This is great. I created something vaguely similar a while back, but probably does not allow for as much complexity. https://github.com/seiferteric/clamp

Very useful thanks!

Question, I find your blog very clean, I imagine the blog is written using a static site generator? If yes which one?