Self-Hosted Smart Directory Navigation: zoxide vs autojump vs fasd

Why Smart Directory Navigation?

The average developer changes directories hundreds of times per day. Each cd /some/deeply/nested/project/path is a context switch that breaks flow. Smart directory navigation tools learn your habits and let you jump to frequently-visited directories with just a few keystrokes — z project instead of cd ~/workspace/clients/acme-inc/project-alpha/frontend.

For related terminal productivity tools, see our modern ls replacements guide and shell customization frameworks comparison. If you work across multiple Git branches, our Git branch management guide is also relevant.

Comparison: zoxide vs autojump vs fasd

zoxide

zoxide is the modern successor to autojump, written in Rust for maximum performance. With over 37,000 GitHub stars and active development, it is the current leader in the smart navigation space. It is so fast that the overhead is imperceptible — even on slow machines.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Install zoxide
cargo install zoxide

# Or via package manager
brew install zoxide
sudo apt install zoxide        # Debian/Ubuntu
sudo pacman -S zoxide          # Arch Linux

# Add to shell (bash)
echo 'eval "$(zoxide init bash)"' >> ~/.bashrc

# For Zsh
echo 'eval "$(zoxide init zsh)"' >> ~/.zshrc

zoxide’s killer feature is the interactive mode. When there are multiple matches, zi opens an fzf-powered picker:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Jump to a directory (fuzzy matching)
z proj      # matches ~/workspace/project-alpha
z down      # matches ~/Downloads

# Interactive mode with fzf
zi          # Opens fuzzy finder with all your directories

# Query the database
zoxide query -l    # List all tracked directories with scores
zoxide query -s    # Show top directories by score
zoxide remove ~/old-project   # Remove a directory from tracking

zoxide uses an SQLite database for storing directory entries, which makes it robust, queryable, and fast. The algorithm uses a frecency (frequency + recency) model with weighted scoring. Directories you visit more often AND more recently get higher scores.

Configuration is simple:

1
2
3
4

# Set via environment variables
export _ZO_MAXAGE=10000        # Max entries in database
export _ZO_EXCLUDE_DIRS="$HOME/Downloads:$HOME/tmp"  # Don't track these
export _ZO_FZF_OPTS="--height 40% --layout reverse --border"

For Fish shell users, zoxide integrates with Fish’s auto-suggestion system seamlessly. For PowerShell users on Windows, zoxide is a game-changer — z proj jumps to your project directory instantly from any location.

autojump

autojump pioneered the concept of learning-based directory navigation. With over 16,900 stars, it has been a staple of developer toolkits for over a decade. It is written in Python and uses a simple text-based database.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Install autojump
pip install autojump

# Or via package manager
brew install autojump
sudo apt install autojump

# Add to shell (bash)
echo '. /usr/share/autojump/autojump.bash' >> ~/.bashrc

# For Zsh
echo '. /usr/share/autojump/autojump.zsh' >> ~/.zshrc

Usage is straightforward:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Jump to directories you have visited
j proj       # Jump to highest-ranked match for "proj"
j down       # Jump to Downloads

# View statistics
j -s         # Show database with scores and weights

# Open file manager in matched directory
jo proj      # Opens highest-ranked "proj" match in file manager
jc proj      # Jump to child of current directory matching "proj"

autojump’s scoring is path-based — it gives weight to the directory name itself, not just the full path. This means /home/user/projects/foo scores similarly to /home/user/old/foo if “foo” matches the query. The database is human-readable, making it easy to audit and manually edit.

The downside is maintenance: the last commit was in February 2025, and development has slowed significantly. Python’s startup overhead adds 30-50ms to every jump, which is noticeable compared to zoxide’s sub-millisecond response.

fasd

fasd (pronounced “fast”) takes a holistic approach — it tracks not just directories, but also files. With over 5,900 stars, it is a POSIX-compliant shell script that works on virtually any Unix-like system without dependencies.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Install fasd
git clone https://github.com/clvv/fasd.git
cd fasd && make install

# Or via package manager
brew install fasd
sudo apt install fasd

# Add to shell
eval "$(fasd --init auto)"  # Add to .bashrc or .zshrc

fasd provides multiple commands:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Directory jumping
z proj       # Jump to highest-ranked directory matching "proj"
zz proj      # Same but uses interactive selection when ambiguous

# File access
f readme     # Open highest-ranked file matching "readme" in $EDITOR
v readme     # Open in $VISUAL or interactive selection

# Combined file + directory
a proj       # Run command on both files and dirs matching "proj"
s proj       # Interactive selection

fasd tracks both files AND directories, which means f readme can open the most frequently accessed README file anywhere on your system with a single command. The ranking algorithm is Bayesian — it calculates the probability that you want a particular path based on access history, balancing recency and frequency.

The downside is that fasd is effectively archived (last commit June 2020). It still works perfectly on modern systems since it is pure POSIX shell, but it will not get new features or bug fixes.

Choosing Your Navigation Tool

Choose zoxide if you want the fastest, most actively maintained solution. It is the clear winner for performance with its Rust implementation, and its interactive mode with fzf is unmatched. The SQLite backend makes it robust and queryable. This is the recommended choice for most users.

Choose autojump if you prefer a battle-tested Python tool with a simple text-based database you can inspect and edit manually. It works well on resource-constrained systems where you cannot install Rust binaries. The jo (open in file manager) and jc (jump to child) features are unique.

Choose fasd if you want file tracking alongside directory tracking, or you need a dependency-free shell script that runs on any POSIX system. If you frequently access the same files from different directories, fasd’s unified file+directory tracking is uniquely useful.

FAQ

How do these tools know which directories I visit?

Each tool hooks into your shell via a prompt command or chpwd hook. Every time you cd to a directory (including via the tool itself), the path and timestamp are recorded in the database. Over time, the tool builds a weighted map of your navigation patterns.

Do these tools work over SSH?

Yes, but with a caveat: the database is local to each machine. If you SSH into a remote server, that server has its own navigation database. For a unified experience across machines, you would need to sync the database file or use the same tool on all machines with similar directory structures.

Can I clear or reset the database?

Yes. For zoxide: zoxide remove --all or delete the SQLite database file. For autojump: delete ~/.local/share/autojump/autojump.txt. For fasd: delete ~/.fasd. The database will rebuild as you navigate.

How is this different from CDPATH or pushd/popd?

CDPATH is a static list of base directories — you still need to type the full relative path. pushd/popd is a LIFO stack that requires explicit management. Smart navigation tools learn your patterns automatically and work with fuzzy matching, requiring only 2-3 characters to jump to deeply nested directories.

Can I exclude certain directories from tracking?

Yes. zoxide supports _ZO_EXCLUDE_DIRS env var. autojump ignores paths matching AUTOJUMP_IGNORE_CASE. fasd respects $_FASD_IGNORE patterns. Common exclusions include ~/Downloads, ~/tmp, and .cache directories.

💰 想测试你的市场判断力？我用 Polymarket 做预测市场交易——这是全球最大的预测市场平台，从大选结果到技术监管时间线，什么都可以押注。和赌博不同，这是真正的信息市场：你懂的信息越多，胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册：Polymarket.com