FZF vs Skim (October 2025): which fuzzy finder should power your terminal?

on

fzf vs skim

When your shell starts feeling slow, the culprit isn’t the CPU—it’s you hunting through files, branches, and history. Fuzzy finders fix that. Two names always bubble up: FZF, the battle-tested classic written in Go, and Skim (sk), the lean Rust-based contender. They share a vocabulary (tokens, multi-select, ANSI, previews), but they don’t share the same story. One is everywhere; the other is focused, nimble, and quietly opinionated.

Let’s cut through the hype and pick the right tool for your hands.

TL;DR

  • Choose FZF if you want the biggest ecosystem, rock-solid Windows/macOS/Linux support, deep shell/editor integrations, click/trigger niceties, and constant releases.
  • Choose Skim (sk) if you prefer Rust tooling, want a drop-in FZF-style UX on Unix-like systems, like its interactive command mode (-c), or you need to embed a fuzzy finder as a Rust library.

What’s new by October 2025?

  • FZF is on the 0.65.x train with steady quality-of-life upgrades. You get click events on the footer/header (fun for tiny TUIs), better edge-case rendering, and an ever-wider prebuilt binary matrix (from Android ARM to LoongArch). Multi-line history display rolled in last year and stuck the landing.
  • Skim saw active updates through 2025 (latest 0.20.x in August). The README explicitly highlights differences vs FZF, and the project continues to embrace a Rust-first approach with a library you can import in your own crates.

The core: search brains and speed

Both tools score candidates using smart, locality-aware matching (yes, that family of dynamic-programming alignments you learned about in algorithms class). In practice:

  • FZF: blazing fast on huge lists; decades of tuning; “good defaults, infinite ceiling.”
  • Skim: competitive and snappy, especially on everyday lists; pragmatic features with a Rust flavor.

Real-world speed depends on your pipeline (fd/rg/git), terminal, and preview commands. The honest advice? Measure your workflow; don’t benchmark feelings.

UX features you’ll actually use

Shared essentials

  • Incremental fuzzy match, multi-select, rich query tokens (^prefix, .ext$, !negate, quoted exact match), ANSI-colored items, and a preview window that pairs perfectly with bat, git, and rg.

Where they diverge

  • FZF:
    • Dynamic reload: bind a key to refresh the source live (great for process lists, kubectl, docker).
    • Clickable UI: footer/header click events, plus trigger(...) to fire bound actions—handy for tiny in-terminal dashboards.
    • Multi-line: shows multi-line entries cleanly (think complex shell history).
  • Skim:
    • Interactive command mode (-c): type a query and have Skim run a command as you type—fantastic for “live grep” or custom lookups with rg, ag, or ack.
    • Preselection and a few Rust-centric ergonomics, plus a tidy set of built-in color schemes.
    • Library mode: import skim into your Rust app and build bespoke pickers.

Ecosystem & platform reality

  • FZF runs everywhere you probably care about—Linux, macOS, and Windows—and it integrates deeply with Bash/Zsh/Fish, Vim/Neovim, PowerShell (via PSFzf), and more.
  • Skim mirrors a lot of the FZF surface area on Unix-like systems and integrates nicely with Neovim plugins (for example, fzf-lua can speak Skim). Windows isn’t officially supported in sk; use FZF if Windows is in your daily mix.

Installation quick hits

FZF

# macOS / Linux (Homebrew)
brew install fzf
# Optional: install keybindings & completion
"$(brew --prefix)/opt/fzf/install"

# Debian/Ubuntu
sudo apt install fzf

# Windows (choose one)
winget install fzf
# or
choco install fzf
# or
scoop install fzf

Skim (sk)

# macOS (Homebrew)
brew install sk

# Arch
sudo pacman -S skim

# Fedora
sudo dnf install skim

# Or with cargo
cargo install skim

90-second setup: better defaults

FZF defaults (with fd and bat)

# Find files fast, including hidden, but skip .git
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

# Friendlier UI: reverse + preview with bat
export FZF_DEFAULT_OPTS='--height=40% --layout=reverse --border --info=inline \
  --preview "bat --style=numbers --color=always --line-range :500 {}" \
  --preview-window=right:60%:wrap'

Skim defaults (same idea)

# Mirror the FZF defaults
export SKIM_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'

# A comfortable UI + preview
alias skf='sk --ansi --prompt="Files> " \
  --preview "bat --style=numbers --color=always --line-range :500 {}" \
  --preview-window=right:60%:wrap'

Live content search, two ways

“Live grep” with FZF (dynamic reload)

rg --line-number --no-heading --color=always "" \
| fzf --ansi --bind 'change:reload:rg --line-number --no-heading --color=always {q} || true' \
      --delimiter : --preview 'bat --style=numbers --color=always --highlight-line {2} {1}' \
      --preview-window=right:70%:wrap

Type to refine; FZF calls rg on every change and refreshes the candidate list.

“Live grep” with Skim (interactive -c)

sk --ansi -c 'rg --line-number --no-heading --color=always "{}"' \
   --delimiter : \
   --preview 'bat --style=numbers --color=always --highlight-line {2} {1}' \
   --preview-window=right:70%:wrap

Your query is interpolated into the command; Skim streams results as you type.

Editor and shell glue that sticks

  • Neovim/Vim: both tools slot into popular pickers; FZF has first-party plugins and enormous community surface area; Skim works nicely via FZF-compatible layers (e.g., fzf-lua with a skim backend).
  • Shell: both expose keybindings for Ctrl-T (files), Alt-C (cd), and Ctrl-R (history).
  • Power users: FZF’s reload/click/trigger primitives let you craft miniature dashboards—git stash browsers, K8s pod pickers, package explorers—directly in your terminal.

Windows story (the deciding factor for many)

  • FZF is first-class on Windows. Install with winget/Chocolatey/Scoop, wire it into PowerShell using PSFzf, and enjoy previews with bat.
  • Skim is currently not supported on Windows. If your day includes Windows—natively or in CI—pick FZF and be done.

Who should pick what?

  • Pick FZF if you want: cross-platform stability, maximal community support, rolling releases, and advanced interaction hooks for building tiny TUIs.
  • Pick Skim if you want: a Rust-native tool on Unix-like systems, a clean -c interactive command mode, and/or the ability to embed a fuzzy finder inside a Rust program.

And the secret option C? Use both. FZF where portability matters; Skim where your Rust stack shines. They speak nearly the same language—you won’t confuse your fingers.

FAQ lightning round

Does Skim understand FZF’s matching syntax?
Yes—prefix/suffix/exact/negation tokens, and combinations with AND/OR.

Can I preview images or non-text?
You can preview anything your shell can render (e.g., chafa/imgcat), but keep it fast; previews run per selection.

Will either tool “fix” slow searches?
They’ll only go as fast as your source. Pair with fd and ripgrep, keep previews cheap, and ignore junk (.git, node_modules, build dirs).

The bottom line

FZF is the universal remote; Skim is the slick boutique controller. One’s everywhere; one’s elegant and focused. Neither is wrong. Pick by platform, ecosystem, and the muscle memory you want to cultivate—and then wire it deep into your daily flow.


Comments

Post a Comment