Learn Fzf - Pre-Requisite Skills & Environment Setup

#Introduction

Welcome to the Learn Fzf series! This series will take you through mastering fzf — the general-purpose command-line fuzzy finder written in Go — from searching for your first file to building a terminal workflow that is fast, efficient, and production-ready. There are 23 episodes in total that build your understanding layer by layer.

But before you type your first fzf command, there are a few basic skills and tools you must have in place. Why are these prerequisites important? Because fzf is not a standalone application — it is an interactive filter that sits in the middle of a pipeline. fzf receives a list of items from another command, displays them in an interactive interface, and then prints the item you select. If you do not yet understand pipelines, environment variables, or how to search for files, fzf will feel like magic — you know the result, but you do not understand why.

Think of fzf as an airport receptionist. You arrive with a passenger list (the output of another command), the receptionist displays it on screen and lets you find a name by typing part of it, and then prints a boarding pass for the name you pick. This episode 0 prepares the passenger list, the screen, and the receptionist all at once.

#Basic Skills You Must Have

fzf is a Command Line Interface (CLI) tool. All of its power is accessed through the terminal — not by clicking buttons. Comfort typing and reading output is your main asset, because throughout this series you will keep writing commands, combining them, and reading the results.

Before you dive into fzf, make sure you are comfortable navigating the terminal. These four commands are enough as a starting point:

Command	Purpose
`pwd`	Prints the current working directory
`ls`	Lists the contents of a directory
`cd`	Moves to another directory
`man`	Reads a command's manual page

#Pipeline, stdin, and stdout

One concept you must understand from the start: stdin and stdout. Many commands write their results to stdout — that is, to your terminal screen. Conversely, many commands also read input from stdin — by default, the keyboard. This output can be redirected to a file with > (redirect) or passed on to another command with | (pipeline).

fzf is the primary consumer of this pattern. Take a look at the most basic example, one you will use again and again throughout the series:

Basic pattern you'll use over and over

ls | fzf

Read the line above out loud: "take the output of ls, pass it to fzf". fzf reads the file list from stdin, displays it interactively, and then prints the item you select to stdout. That output can be piped on to the next command — for example ls | fzf | xargs cat. Understand this pattern now, because all of fzf's power starts from here.

#Environment Variables & Shell Configuration Files

Your shell preferences live in configuration files that are read every time a session starts: ~/.bashrc for Bash, ~/.zshrc for Zsh, and config.fish for Fish. This is where you will store aliases, functions, and fzf's default options, which we cover in the following episodes.

The rule of thumb is simple: anything you want active in every session, write it in your shell configuration file. Here is a small example you can try right away — an alias for fzf:

~/.bashrc - example contents for fzf

# ~/.bashrc - Bash shell configuration
# Alias to make fzf easy to reach
alias ff='fzf --height=50% --border'
 
# Global default options for all fzf
export FZF_DEFAULT_OPTS="--layout=reverse --info=inline"

After editing, reload the configuration with source ~/.bashrc (for Fish: source ~/.config/fish/config.fish). Do not worry about the option values right now — --layout and --info are dissected thoroughly in episode 4. What matters here: you now know where these preferences live.

#Finding Files: The Basics of find, grep, and ripgrep

fzf is most often paired with commands that search for files and file contents. Get to know the three commands below, because they will accompany almost every example in this series:

Command	Purpose	Example
`find`	Walks the directory structure by name	`find . -name "*.md"`
`grep`	Searches for text inside files	`grep "error" app.log`
`rg` (ripgrep)	A much faster replacement for grep	`rg "error" app.log`

Here is the pattern you will see often: a search command produces a list, and that list is passed to fzf. For example find . -type f | fzf to pick a file, or rg --files | fzf which is faster in large repos. If find is how you locate files by name and grep/rg is how you locate them by content, then fzf is how you choose one from many results — a job grep cannot do on its own, because grep only filters; it does not offer a menu of choices.

#Setting Up the Fzf Environment

#Installation via Package Manager

fzf 0.74.x is available in the repositories of most Linux distributions and in Homebrew. Install it according to your system:

sudo apt update
sudo apt install fzf

If the version in your distribution's repository lags behind 0.74.x, do not worry — fzf releases are very frequent, and some distributions package older versions. The two options below (the install script and building from source) always give you the latest version.

#Official Install Script

The method recommended by the fzf project itself — a script that downloads, compiles, and sets up shell integration in one go:

fzf official install script

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

During the process, the script asks whether you want to enable keybindings (Ctrl+T, Ctrl+R, Alt+C) and fuzzy completion in your shell. Answer y if you want to feel fzf's full power right away — we dive deep into this integration in episodes 7 and 8 of this series.

#Building from Source (Go)

fzf is written in Go, so building it from source is very easy — the result is a single binary you can place anywhere:

Build from source

git clone --depth 1 https://github.com/junegunn/fzf.git
cd fzf
make
sudo make install

You need the Go toolchain on your system. This method is most useful when you want the latest fzf binary on a system whose package manager lags behind, or when you want to install fzf to a private directory without root access (make install PREFIX=$HOME/.local).

#Verifying the Installation

Once installed, verify that fzf 0.74.x is really there and ready to use:

Check the fzf version

fzf --version

Example output

0.74.1 (2a8d6c0)

The output above shows two things: fzf's version (0.74.1) and the commit hash of the build (2a8d6c0). This series assumes fzf 0.74.x. If your version differs significantly, some features covered here may differ slightly — but the core concepts remain the same.

#Supporting Tools

fzf is great on its own, but the four tools below will make your experience much more enjoyable throughout the series:

Tools	Purpose in This Series	Verification
`rg` (ripgrep)	A very fast source of file and content lists	`rg --version`
`fd`	A friendly, fast replacement for `find`	`fd --version`
`bat`	`cat` with syntax highlighting for colorful previews	`bat --version`
True Color Terminal	Supports 24-bit color for previews and themes	`echo $COLORTERM`

bat will play a big role in the episodes about the preview window — fzf can display a live preview of files, and bat makes that preview colorful. Your terminal needs to support True Color (24-bit) for those colors to render perfectly; most modern terminals — Alacritty, Kitty, WezTerm, Windows Terminal, iTerm2 — have supported it for a long time.

Verify everything is installed by running:

Verify the supporting tools

rg --version
fd --version
bat --version
echo $COLORTERM

#Episode 0 Checklist Summary

Comfortable typing in the terminal (pwd, ls, cd, man).
Understand the stdin/stdout pipeline — especially the command | fzf pattern.
Know where the shell configuration files live (~/.bashrc, ~/.zshrc, config.fish) and how to reload them.
Familiar with find, grep, and rg as sources of item lists.
fzf --version shows fzf 0.74.x.
rg, fd, and bat are installed, and the terminal supports True Color.

#Closing

In this episode 0 you have laid the foundation for the entire series: understanding the basic CLI skills and the stdin/stdout pipeline, learning about environment variables and shell configuration files, mastering the basics of find, grep, and rg, installing fzf 0.74.x along with its verification, and completing the supporting tools rg, fd, and bat.

The key takeaways:

fzf is an interactive filter in the middle of a pipeline — it reads from stdin and prints to stdout.
The most decisive basic skill is understanding pipelines and being comfortable in the terminal.
Verify your build with fzf --version: make sure the version is 0.74.x.
Have rg, fd, and bat ready as companions throughout the series.

In the next episode, episode 1, we will cover the history, background, and why the world needed fzf — from the small Vim plugin for searching files that Junegunn Choi wrote in 2013, to becoming the de-facto standard fuzzy finder in the terminal ecosystem. Make sure your environment is ready, because the Learn Fzf journey has only just begun!