How to Install Yazi on Ubuntu

Yazi is a fast terminal file manager for Ubuntu and other Linux systems. You navigate folders, preview images and PDFs, search with ripgrep (rg), and jump with fzf and zoxide—all without leaving the shell. It is a common upgrade from older TUI managers like Ranger when you want async I/O and a plugin system.

This guide walks through every practical way to install Yazi on Ubuntu: the official GitHub .deb, a portable zip, Snap, Flatpak, Cargo, and the community APT repo at debian.griffo.io. I ran these steps on Ubuntu 25.04 and kept the real terminal output below so you can compare your machine. Where something bit me—wrong zip paths, a missing fd binary, a 404 from the griffo repo—you will find the fix in the same section.

If you are still picking a base OS, Debian 12 vs Ubuntu 24.04 LTS is a useful side read.

Tested on: Ubuntu 25.04 (Plucky Puffin); kernel 6.14.0-37-generic.

Quick command summary

What is Yazi?

Yazi (yazi means “duck” in Chinese) is a TUI file manager built in Rust with non-blocking async I/O. Compared with classic terminal file managers, it emphasizes:

• Fast directory listing and preview loading
• Image, video, PDF, and code previews (when helper tools are installed)
• A Lua plugin system managed with the ya CLI
• Integrations with fd, rg, fzf, and zoxide

You run it by typing yazi in any modern terminal emulator. Configuration lives under ~/.config/yazi/ (yazi.toml, keymap.toml, themes, and plugins).

Prerequisites

You need:

• Ubuntu 22.04 LTS, 24.04 LTS, or newer (including non-LTS releases such as 25.04).
• A terminal emulator (GNOME Terminal, Kitty, Alacritty, WezTerm, etc.). Long-running installs pair well with GNU Screen or tmux if you are on SSH.
• wget or curl, and sudo for system-wide installs.
• For the zip method: unzip (see also extracting archives in Linux if you work with tarballs alongside zips).
• For Flatpak: sudo apt install flatpak if the flatpak command is missing.
• For Cargo: build-essential and a Rust toolchain from rustup (see Go vs Rust if you are choosing a systems language stack).
• Enough free disk for downloads and previews—check disk space before you aim Yazi at a huge torrent or media tree.

Only file is strictly required by upstream; everything else unlocks previews and search features covered in the next section.

Optional dependencies (strongly recommended)

The official installation docs list tools Yazi calls for previews and navigation:

Install the common set in one step (you need this yourself on the zip path; the GitHub .deb pulls most of them in through apt):

sudo apt update
sudo apt install -y file ffmpeg 7zip jq poppler-utils fd-find ripgrep fzf zoxide imagemagick xsel unzip

Ubuntu names fd as fdfind

This one caught me after the .deb install. The fd-find package is present, but the executable is fdfind, not fd:

command -v fd || echo "fd: not on PATH"
command -v fdfind

fd: not on PATH
/usr/bin/fdfind

Yazi’s file search looks for fd. A one-line symlink fixes it (use which or command -v to confirm what your shell resolves):

sudo ln -sf /usr/bin/fdfind /usr/local/bin/fd
command -v fd && fd --version

/usr/local/bin/fd
fdfind 10.2.0

The version string still says fdfind—that is normal on Ubuntu. As long as command -v fd returns a path, search inside Yazi should work.

For more on installing jq on Debian-based systems, see install jq on Ubuntu.

Install Yazi on Ubuntu

Pick one method and stick with it.

Method 1: Official GitHub .deb (recommended)

The Yazi project publishes .deb files on GitHub Releases for x86_64 and aarch64 (ARM64). This is the route I would use on a normal Ubuntu desktop or server. Download with wget and install the local package with apt (same idea as dpkg for a single .deb file).

On x86_64:

wget -qO yazi.deb https://github.com/sxyazi/yazi/releases/latest/download/yazi-x86_64-unknown-linux-gnu.deb
sudo apt install -y ./yazi.deb

On ARM64 (aarch64):

wget -qO yazi.deb https://github.com/sxyazi/yazi/releases/latest/download/yazi-aarch64-unknown-linux-gnu.deb
sudo apt install -y ./yazi.deb

On Ubuntu 25.04 the tail of apt install looked like this:

Get:1 /tmp/yazi.deb yazi amd64 26.5.6-1 [7,281 kB]
Selecting previously unselected package yazi.
Unpacking yazi (26.5.6-1) ...
Setting up yazi (26.5.6-1) ...

Check the build:

yazi --version
ya --version

Yazi 26.5.6 (aa52643 2026-05-05)
Ya 26.5.6 (aa52643 2026-05-05)

Both binaries land in /usr/bin/. Bash completions go under /usr/share/bash-completion/completions/.

Do not forget the fd symlink after install if file search is empty.

Method 2: Official zip binary (manual install)

Use this when you want upstream binaries but cannot install the .deb through apt (air-gapped mirror, custom rootfs, and similar cases). You will download with wget and unpack the zip yourself—similar in spirit to pulling binaries from a tar archive, but Yazi ships a zip on GitHub.

cd /tmp
wget -qO yazi.zip https://github.com/sxyazi/yazi/releases/latest/download/yazi-x86_64-unknown-linux-gnu.zip
unzip -q yazi.zip
sudo install -m 755 yazi-x86_64-unknown-linux-gnu/yazi yazi-x86_64-unknown-linux-gnu/ya /usr/local/bin/
rm -rf yazi.zip yazi-x86_64-unknown-linux-gnu

Current release zips unpack into a folder named after the architecture—not yazi-temp:

completions
LICENSE
README.md
ya
yazi

yazi --version

Yazi 26.5.6 (aa52643 2026-05-05)

Method 3: Third-party APT repository (debian.griffo.io)

The Yazi installation docs point to an unofficial repo maintained by dariogriffo/yazi-debian. It is handy if you want apt upgrade to track Yazi—but read the codename caveat below before you paste the repo line. You will use curl to import the signing key and apt-cache to compare package candidates.

Ubuntu 25.04: plucky gives a 404

The docs show $(lsb_release -sc) in the deb line. On Ubuntu 25.04 that expands to plucky, and apt update dies:

Err:9 https://debian.griffo.io/apt plucky Release
  404  Not Found
Error: The repository 'https://debian.griffo.io/apt plucky Release' does not have a Release file.

Working setup for Ubuntu 24.04 / 25.04:

sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://debian.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/debian.griffo.io.gpg
echo "deb [signed-by=/etc/apt/keyrings/debian.griffo.io.gpg] https://debian.griffo.io/apt noble main" | sudo tee /etc/apt/sources.list.d/debian.griffo.io.list
sudo apt update
sudo apt install -y yazi

apt-cache policy yazi then showed:

yazi:
  Candidate: 26.5.6-2+noble
     26.5.6-2+noble 500
        500 https://debian.griffo.io/apt noble/main amd64 Packages

Install output:

Get:1 https://debian.griffo.io/apt noble/main amd64 yazi amd64 26.5.6-2+noble [7,884 kB]
Setting up yazi (26.5.6-2+noble) ...
Yazi 26.5.6 (aa52643 2026-05-05)

If add-apt-repository is missing on a minimal image, see add-apt-repository command not found.

Method 4: Snap

The upstream author publishes a classic Snap:

sudo snap install yazi --classic

yazi shipped from Ika (sxyazi) installed
Yazi 26.5.6 (aa526434 2026-05-05)
yazi is /snap/bin/yazi

Nightly track:

sudo snap install yazi --classic --edge

snap info yazi on my host listed publisher Ika (sxyazi), MIT license, and the usual async I/O / image-preview blurb from the store page.

Method 5: Flatpak (quick trial)

Flatpak was not installed on my minimal Ubuntu 25.04 image, so the first step was an apt install:

sudo apt install -y flatpak
flatpak --version

Flatpak 1.16.0

Then:

sudo flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
sudo flatpak install -y flathub io.github.sxyazi.yazi
flatpak run io.github.sxyazi.yazi --version

Installation complete.
Yazi 25.12.29 (f31147d 2011-11-11)

That installed fine, but the Flathub build was 25.12.29 while the GitHub .deb and Snap were on 26.5.6 the same day. If you care about the newest release, skip Flatpak for daily use.

Handy alias if you keep it:

alias yazi='flatpak run io.github.sxyazi.yazi'

Method 6: Install with Cargo (developers)

If you already live in Rust-land, cargo install yazi-build compiles Yazi on your machine. Budget time: on my VM the compile pass alone took 22 minutes 43 seconds. Install rustup with curl (same flags you would use for any HTTPS bootstrap script):

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source "$HOME/.cargo/env"
rustup update
sudo apt install -y build-essential pkg-config
cargo install --force yazi-build

Rust toolchain on the same host:

rustc 1.96.0 (ac68faa20 2026-05-25)

Near the end of the compile:

Compiling yazi-tty v26.5.9
   Compiling yazi-build v26.5.9
    Finished `release` profile [optimized] target(s) in 22m 43s
  Installing /home/golinuxcloud/.cargo/bin/yazi-build
   Installed package `yazi-build v26.5.9` (executable `yazi-build`)

The file manager binaries land next to it:

~/.cargo/bin/yazi --version
~/.cargo/bin/ya --version

Yazi 26.5.6 (aa52643 2026-06-24)
Ya 26.5.6 (aa52643 2026-06-24)

Make sure ~/.cargo/bin is on your PATH (rustup usually adds this for you). If binaries are not found after login, see where to set environment variables in Linux and bashrc vs bash_profile:

echo 'source "$HOME/.cargo/env"' >> ~/.bashrc
source ~/.bashrc

First launch and basic usage

Open Yazi in the current directory:

yazi

Or jump straight into a folder:

yazi ~/Downloads

Essential keys (default Vim-style layout):

The first time you run it, Yazi creates ~/.config/yazi/ with default yazi.toml and keymap.toml.

"Terminal response timeout"

I tried launching Yazi inside a bare script session (no real terminal UI). It bailed immediately:

Terminal response timeout: The request sent by Yazi didn't receive a correct response.
Please check your terminal environment as per: https://yazi-rs.github.io/docs/faq#trt

Shell integration (optional)

A small wrapper lets your shell cd to wherever you were when you quit Yazi:

function yy() {
  local tmp="$(mktemp -t "yazi-cwd.XXXXXX")"
  yazi "$@" --cwd-file="$tmp"
  if cwd="$(cat -- "$tmp")" && [ -n "$cwd" ] && [ "$cwd" != "$PWD" ]; then
    cd -- "$cwd"
  fi
  rm -f -- "$tmp"
}

Drop that into ~/.bashrc or ~/.zshrc—see bashrc vs bash_profile if you are unsure which file your login shell reads—and use yy instead of yazi when you want the directory to stick after you press q.

Uninstall Yazi

GitHub .deb or griffo APT package

sudo apt purge -y yazi
sudo apt autoremove -y

If you added the griffo repo:

sudo rm -f /etc/apt/sources.list.d/debian.griffo.io.list /etc/apt/keyrings/debian.griffo.io.gpg
sudo apt update

Zip / manual install

sudo rm -f /usr/local/bin/yazi /usr/local/bin/ya

Remove the fd symlink only if nothing else needs it:

sudo rm -f /usr/local/bin/fd

Snap

sudo snap remove yazi

Flatpak

flatpak uninstall -y io.github.sxyazi.yazi

Cargo

rm -f ~/.cargo/bin/yazi ~/.cargo/bin/ya ~/.cargo/bin/yazi-build

Troubleshooting

For deeper debugging: YAZI_LOG=debug yazi.

References

• Yazi installation docs
• Yazi quick start
• GitHub Releases (official binaries)
• Snap Store: yazi
• Flathub: io.github.sxyazi.yazi
• wget command in Linux
• curl command in Linux
• apt command in Linux
• apt-cache command in Linux
• dpkg command in Linux
• install jq on Ubuntu
• install FFmpeg / ffprobe on Ubuntu
• grep command in Linux
• check disk space in Linux
• top command in Linux
• how to check CPU utilization in Linux
• add-apt-repository command not found

Summary

The path I recommend on Ubuntu is the official yazi-x86_64-unknown-linux-gnu.deb: one apt install, dependencies come along, and you get 26.5.6 with both yazi and ya in /usr/bin/. The zip route works the same version if you point at yazi-x86_64-unknown-linux-gnu/ (not the outdated yazi-temp paths floating around the web). Snap is equally current; Flatpak installed but shipped an older 25.12.29 build when I tried it. The griffo repo works on 25.04 only if you use the noble codename—plucky 404s today.

Whichever route you pick, symlink fd from fdfind on Ubuntu, launch from a real terminal, and keep one install channel on disk. Configure under ~/.config/yazi/, manage plugins with ya, and use the yy wrapper when you want your shell directory to follow you out of Yazi. For day-to-day package work on Debian-based systems, keep the apt and curl cheat sheets nearby when you add repos or fetch release keys.