cheat sheet

eza / exa

A modern ls replacement with colour coding, Git status, icons, tree view, and rich metadata. eza is the actively maintained fork of the original exa project.

updated 05-25-2026

eza / exa — Modern ls

What it is

eza is a free, open-source Rust-based replacement for ls, maintained as the active community fork of the original exa project (which is no longer maintained). It adds color-coded output, Git status indicators in the file listing, optional icons, tree view, and richer metadata columns — all through the same flag conventions as ls. Reach for eza when you want a more readable, information-dense directory listing in an interactive shell; for scripts that will run on arbitrary systems, plain ls remains the safest portable choice.

Note: exa is no longer maintained. eza is the actively maintained fork and drop-in replacement. Both share the same flags. Since v0.20.0, eza is licensed under EUPL-1.2 (the original exa was MIT).

Version note: examples in this article assume eza 0.20+. Several flags called out below — --hyperlink, --absolute, --follow-symlinks, --total-size, the YAML theme.yml, and the tri-state --icons=auto|always|never / --classify=auto|always|never — were added between 0.18 and 0.21. Older builds will reject them; check with eza --version.

Installation

bash

sudo apt install eza           # Debian/Ubuntu (24.04+)
sudo dnf install eza           # Fedora 39+
brew install eza               # macOS / Linux via Homebrew
cargo install eza              # via cargo

# Older systems — install exa
sudo apt install exa

Output: (none — exits 0 on success)

Basic listing

Running eza without flags produces a colorized, single-row listing similar to ls, with file types distinguished by color. Add -l for a long-format view that includes permissions, size, owner, and timestamp.

bash

eza                            # basic list (coloured)

Output:

csharp

Cargo.lock  Cargo.toml  LICENSE  README.md  src/  target/  tests/

bash

eza -l                         # long list (like ls -l)

Output:

lua

.rw-r--r-- 12k alice  24 Apr 14:30 Cargo.lock
.rw-r--r--  842 alice  24 Apr 14:28 Cargo.toml
.rw-r--r--  1.1k alice  10 Jan 09:15 LICENSE
.rw-r--r--  3.4k alice  24 Apr 12:00 README.md
drwxr-xr-x    - alice  24 Apr 14:30 src/
drwxr-xr-x    - alice  24 Apr 14:31 target/
drwxr-xr-x    - alice  20 Apr 10:45 tests/

bash

eza -la                        # long list including hidden files

Output:

lua

drwxr-xr-x    - alice  24 Apr 14:31 ./
drwxr-xr-x    - alice  23 Apr 09:00 ../
drwxr-xr-x    - alice  24 Apr 14:28 .git/
.rw-r--r--   42 alice  20 Apr 10:00 .gitignore
.rw-r--r-- 12k alice  24 Apr 14:30 Cargo.lock
.rw-r--r--  842 alice  24 Apr 14:28 Cargo.toml
.rw-r--r--  1.1k alice  10 Jan 09:15 LICENSE
.rw-r--r--  3.4k alice  24 Apr 12:00 README.md
drwxr-xr-x    - alice  24 Apr 14:30 src/
drwxr-xr-x    - alice  24 Apr 14:31 target/
drwxr-xr-x    - alice  20 Apr 10:45 tests/

bash

eza -lh                        # long list with human-readable sizes
eza -la --sort=size            # sort by size

Output:

lua

drwxr-xr-x    - alice  24 Apr 14:31 target/
.rw-r--r-- 12k alice  24 Apr 14:30 Cargo.lock
.rw-r--r--  3.4k alice  24 Apr 12:00 README.md
.rw-r--r--  1.1k alice  10 Jan 09:15 LICENSE
.rw-r--r--  842 alice  24 Apr 14:28 Cargo.toml
.rw-r--r--   42 alice  20 Apr 10:00 .gitignore
drwxr-xr-x    - alice  24 Apr 14:30 src/
drwxr-xr-x    - alice  20 Apr 10:45 tests/
drwxr-xr-x    - alice  24 Apr 14:28 .git/

bash

eza -la --sort=modified        # sort by modification time
eza -la --sort=ext             # sort by extension
eza -la -r                     # reverse sort
eza -1                         # one file per line
eza -x                         # horizontal grid layout

Output: (none — exits 0 on success)

Metadata columns (`-l`)

The long format shows permissions, file size, owner, and modification time as separate columns. Each column can be individually hidden or reformatted — useful for scripting or narrowing display to just the information you need.

bash

eza -l --no-permissions        # hide permissions column
eza -l --no-filesize           # hide file size
eza -l --no-user               # hide owner
eza -l --no-time               # hide timestamps
eza -l --octal-permissions     # show permissions in octal (e.g. 0644)
eza -l --time=modified         # show modification time (default)
eza -l --time=accessed         # show access time
eza -l --time=created          # show creation time (macOS/BSD)
eza -l --time-style=relative   # "2 hours ago"
eza -l --time-style=long-iso   # "2025-04-24 14:32:00"
eza -l --time-style=full-iso   # with nanoseconds
eza -l --inode                 # show inode number
eza -l --links                 # show hard link count
eza -l --blocks                # show number of filesystem blocks

Output: (none — exits 0 on success)

Hidden files

By default eza omits dot-files, matching ls behaviour. -a reveals them; -A does the same but skips the . and .. entries that are rarely useful interactively.

bash

eza -a                         # include hidden (dot) files
eza -A                         # include hidden, but exclude . and ..
eza -la                        # long + all

Output: (none — exits 0 on success)

Tree view

--tree (or -T) recursively expands the directory into an indented tree, similar to the standalone tree command but with eza's colouring and metadata. Use --level to cap depth; without it, eza descends the entire directory hierarchy.

bash

eza --tree                     # recursive tree (like tree command)

Output:

css

.
├── Cargo.lock
├── Cargo.toml
├── LICENSE
├── README.md
├── src
│   ├── main.rs
│   ├── lib.rs
│   └── utils
│       ├── mod.rs
│       └── parser.rs
└── tests
    └── integration_test.rs

bash

eza --tree --level=2           # limit depth
eza --tree -l                  # tree with long format
eza --tree --level=3 src/      # tree a specific directory
eza -T                         # shorthand for --tree
eza -lT --level=2 .            # long tree, 2 levels deep

Output: (none — exits 0 on success)

Git integration

--git adds a two-character status column — one for the index state, one for the working-tree state — to each file in a long listing. This lets you see at a glance which files are modified or untracked without running git status separately.

bash

eza -l --git                   # show Git status per file

Output:

lua

.rw-r--r-- 12k alice  24 Apr 14:30 -- Cargo.lock
.rw-r--r--  842 alice  24 Apr 14:28 -- Cargo.toml
.rw-r--r--  3.4k alice  24 Apr 12:00 M  README.md
drwxr-xr-x    - alice  24 Apr 14:30 -- src/
drwxr-xr-x    - alice  20 Apr 10:45 N  tests/

bash

eza -l --git --git-repos       # show repo status for directories

Output: (none — exits 0 on success)

Git status symbols:

Symbol	Meaning
`-`	Not modified
`M`	Modified
`N`	New (untracked)
`A`	Added to index
`D`	Deleted
`R`	Renamed
`U`	Updated but unmerged
`I`	Ignored

Icons (requires Nerd Font)

--icons prepends a small glyph to each entry to indicate its file type or language — a folder icon for directories, a language-specific icon for source files, and so on. This requires a Nerd Font installed and selected in your terminal emulator; without one, the glyphs render as boxes.

bash

eza --icons                    # file-type icons
eza -la --icons                # long list with icons

Output:

lua

drwxr-xr-x    - alice  24 Apr 14:28  .git/
.rw-r--r--   42 alice  20 Apr 10:00  .gitignore
.rw-r--r-- 12k alice  24 Apr 14:30  Cargo.lock
.rw-r--r--  842 alice  24 Apr 14:28  Cargo.toml
.rw-r--r--  3.4k alice  24 Apr 12:00  README.md
drwxr-xr-x    - alice  24 Apr 14:30  src/

bash

eza -T --icons --level=2       # tree with icons

Output: (none — exits 0 on success)

Filtering

These flags narrow the listing to specific entry types without a separate grep or find pass. --only-dirs and -D are equivalent; --only-files requires eza 0.17 or later.

bash

eza -l --only-dirs             # directories only
eza -l --only-files            # files only (eza 0.17+)
eza -l --no-symlinks           # hide symlinks
eza -l -D                      # shorthand: dirs only

Output: (none — exits 0 on success)

Sorting options

Value	Sort by
`name`	filename (default)
`size`	file size
`modified` / `date`	modification time
`accessed`	access time
`created`	creation time
`inode`	inode number
`extension` / `ext`	file extension
`type`	file type (dirs first)
`none`	directory order

bash

eza -la --sort=size -r          # largest first

Output:

lua

drwxr-xr-x    - alice  24 Apr 14:31 target/
.rw-r--r-- 12k alice  24 Apr 14:30 Cargo.lock
.rw-r--r--  3.4k alice  24 Apr 12:00 README.md
.rw-r--r--  1.1k alice  10 Jan 09:15 LICENSE
.rw-r--r--  842 alice  24 Apr 14:28 Cargo.toml
.rw-r--r--   42 alice  20 Apr 10:00 .gitignore
drwxr-xr-x    - alice  24 Apr 14:30 src/
drwxr-xr-x    - alice  20 Apr 10:45 tests/

bash

eza -la --sort=modified -r      # most recently modified first
eza -la --group-directories-first  # dirs before files

Output: (none — exits 0 on success)

Colour and display

By default eza emits colour only when writing to a terminal (auto). Force it on with always when piping into tools like less -R, or off with never for plain-text output. --colour-scale shades file-size values across a gradient so large files visually stand out.

bash

eza --colour=always             # force colour (for piping)
eza --colour=never              # disable colour
eza --colour=auto               # colour only if TTY (default)
eza --colour-scale              # gradient colour for file sizes
eza --colour-scale-mode=gradient  # or 'fixed'

Output: (none — exits 0 on success)

--icons and --classify (since 0.15 / 0.18) accept the same tri-state — useful when you want icons in your interactive alias but not when the same alias is piped:

bash

eza --icons=auto                # icons only when TTY (default if installed)
eza --icons=always              # force icons even when piped
eza --icons=never               # disable, overriding aliases
eza --classify=auto -l          # append /, *, @ only on TTY
eza --classify=always -l        # force the indicators (= old -F)

Output: (none — exits 0 on success)

Hyperlinks (OSC 8)

--hyperlink (eza 0.18+) wraps every entry name in an OSC 8 escape sequence so the terminal renders it as a clickable link. In supported emulators — iTerm2, WezTerm, Kitty, Ghostty, recent GNOME Terminal and Konsole — Cmd-click (macOS) or Ctrl-click (Linux/Windows) opens the file in its default app and a directory in your file manager. Terminals that don't understand OSC 8 silently ignore the codes, so the flag is safe to leave on in aliases.

bash

eza --hyperlink                # clickable file/dir names
eza -la --hyperlink --icons    # combine with long format and icons
eza -T --hyperlink --level=2   # clickable tree

Output: (none — exits 0 on success)

Test whether your terminal honours OSC 8 before relying on it:

bash

printf '\033]8;;https://example.com\033\\click me\033]8;;\033\\\n'

Output: (in OSC 8-capable terminals, "click me" renders as a clickable link)

Filenames containing spaces don't always activate in every terminal — this is a known eza limitation tracked upstream. Most paths are fine; quote-heavy filenames may fall back to plain text.

Absolute paths and symlink following

--absolute (eza 0.18.6+) prints the absolute path of each entry instead of just the basename — useful when piping into editors, xargs, or copy-paste into another shell. --follow-symlinks (eza 0.20.1+) descends through symlinked directories rather than treating them as opaque pointers; combine with -T to walk a project that uses symlinks for shared submodules.

bash

eza --absolute                 # print absolute paths
eza -l --absolute --no-user --no-time
eza -T --follow-symlinks --level=2
eza -l --show-symlinks         # explicit (default behaviour)
eza -l --no-symlinks           # hide symlinks entirely (0.18.20+)

Output:

swift

/home/alice/project/Cargo.lock
/home/alice/project/Cargo.toml
/home/alice/project/README.md
/home/alice/project/src/

Pair --absolute with fzf or xargs (see sections/linux/fd-find) to build pipelines that need full paths without a separate realpath pass.

Aliases to replace ls

bash

# ~/.bashrc or ~/.zshrc
alias ls='eza --colour=auto'
alias la='eza -la'
alias ll='eza -lh'
alias lt='eza -lT --level=2'
alias lg='eza -la --git'
alias tree='eza -T --level=3'

Output: (none — exits 0 on success)

eza vs ls equivalents

ls	eza
`ls -l`	`eza -l`
`ls -la`	`eza -la`
`ls -lh`	`eza -lh`
`ls -ltr`	`eza -l --sort=modified -r`
`ls -lS`	`eza -l --sort=size -r`
`ls --color=always`	`eza --colour=always`
`tree -L 2`	`eza -T --level=2`

Install a Nerd Font (e.g. JetBrainsMono Nerd Font) in your terminal emulator to unlock --icons with proper file-type glyphs. Most modern terminals (WezTerm, Kitty, Alacritty) support Nerd Fonts natively.

Classic ls flags vs. eza flags

eza accepts every common ls short flag, plus some long-form options that ls doesn't have. The table below maps the muscle-memory ls flags to their eza equivalents — most are identical, a few have eza-specific upgrades.

Flag	`ls` meaning	`eza` equivalent / notes
`-l`	long format	same
`-a`	all files (incl. `.` and `..`)	same
`-A`	all but `.` and `..`	same
`-h`	human-readable sizes	same (and the default in `-l`)
`-r`	reverse sort	same
`-S`	sort by size	same
`-t`	sort by mtime	same
`-d`	list directories themselves	`-d` / `--treat-dirs-as-files` (0.22+; `--list-dirs` retained as alias)
`-1`	one entry per line	same
`-x`	grid horizontally	same
`-G`	grid (multi-column)	same
`-F`	append type indicator (`/`, `*`, `@`)	`-F` / `--classify`
`-R`	recurse	`-R` / `--recurse` (consider `-T` instead)
`-i`	show inode	`--inode`
`-s`	show filesystem blocks	`--blocks`
`--color=auto`	colorize when TTY	`--color=auto` (or `--colour=auto`)

bash

eza -lha                       # like `ls -lha`
eza -lrt                       # long, reverse, sort by mtime  (= `ls -ltr`)
eza -lSr                       # long, largest first  (= `ls -lSr` or `ls -lS`)
eza -d */                      # only top-level dirs
eza -F                          # append /, @, * indicators
eza -1                          # one entry per line — good for piping

Output:

css

src/
target/
tests/
docs/
README.md
LICENSE
Cargo.toml

Tree view in depth

-T (or --tree) draws a directory tree using box-drawing characters. The flag pairs with --level (or -L) to cap depth and with --git-ignore to hide files listed in .gitignore. Add -l for a long-format tree that shows size and timestamps alongside the hierarchy.

bash

eza -T                            # full recursive tree (slow on big trees!)
eza -T --level=1                   # one level — same as plain eza
eza -T --level=2                   # two levels deep
eza -T --level=3 -lh               # 3 levels, long format, human sizes
eza -T --git-ignore                # respect .gitignore
eza -T -I 'node_modules|target|.git'   # exclude patterns
eza -aT --level=2                  # tree including hidden files
eza -T --no-permissions --no-user --no-time   # narrow tree

Output:

css

.
├── src
│   ├── main.rs
│   ├── lib.rs
│   └── utils
│       ├── mod.rs
│       └── parser.rs
└── tests
    └── integration_test.rs

Always pair -T with --level=N on unfamiliar directories. A top-level eza -T in ~ or / will try to descend the entire filesystem.

--git deep dive

--git adds a two-character status column to -l output: position 1 is the staged (index) status, position 2 is the working tree status. This mirrors git status --short and lets you see at a glance what is dirty in the current directory without leaving ls.

Symbol	Meaning
`-`	unchanged in that slot
`M`	modified
`N`	new / untracked
`A`	added to index
`D`	deleted
`R`	renamed
`C`	copied
`U`	unmerged (conflict)
`T`	type changed (file ↔ symlink)
`I`	ignored

The first character shows index state, the second shows worktree state. So MM means "staged modifications plus further unstaged edits"; -M means "unstaged modifications only"; A- means "newly added and clean since."

bash

eza -l --git
eza -l --git --git-repos          # show repo state for nested repos
eza -l --git --git-ignore         # hide gitignored files
eza -lT --git --level=2           # tree with git status

Output:

lua

.rw-r--r-- 12k alice  24 Apr 14:30 -- Cargo.lock
.rw-r--r--  842 alice  24 Apr 14:28 -- Cargo.toml
.rw-r--r--  3.4k alice  24 Apr 12:00 M- README.md
.rw-r--r--   80 alice  24 Apr 14:31 MM src/main.rs
.rw-r--r--   12 alice  24 Apr 14:31 A- src/new_module.rs
drwxr-xr-x    - alice  20 Apr 10:45 N- tests/

--git-repos extends the marker to nested git repositories — useful when listing a directory full of cloned projects to see which are dirty.

Extended attributes and ACLs

-@ (or --extended) reveals macOS extended attributes (xattrs) and Linux POSIX ACLs that are otherwise invisible. The output adds an extra indented line per attribute under each file that has any.

bash

eza -l@ ~/Downloads               # show xattrs on macOS downloads
eza -l@ /path/with/acls

Output:

css

.rw-r--r--@ 2.4M alice  24 Apr 14:30 installer.dmg
                   com.apple.macl: 60 bytes
                   com.apple.metadata:kMDItemWhereFroms: 132 bytes
                   com.apple.quarantine: 22 bytes

Files downloaded by Safari and Chrome on macOS carry a com.apple.quarantine xattr that triggers Gatekeeper warnings. Use xattr -d com.apple.quarantine FILE to clear it — see also permissions.

Filesystem and mount columns

--filesystem adds a column showing which filesystem each entry lives on — invaluable on multi-mount setups, container hosts, and macOS systems with APFS firmlinks.

bash

eza -l --filesystem /var/log /home/alice/data

Output:

bash

.rw-r--r--   12k root  24 Apr 14:30 /                /var/log/syslog
.rw-r--r--  4.2k alice 24 Apr 14:28 /home (sda3)     /home/alice/data/notes.md

--mounts flags directories that are mount points with a special indicator. Useful when piping output to spot crossings.

Custom color schemes

eza honors two environment variables: LS_COLORS (shared with ls, tree, fd) and the eza-specific EZA_COLORS (which overrides LS_COLORS for eza only). Each is a colon-separated list of KEY=ANSI_CODE pairs. See the upstream theme repository for ready-made schemes.

Key	Affects
`di`	directories
`ln`	symbolic links
`ex`	executables
`fi`	regular files
`pi`	named pipes
`so`	sockets
`*.ext`	files by extension
`da`	timestamps
`uu`	your own files
`un`	other users' files
`ur`, `uw`, `ux`	permission bits
`gm`, `gn`, `ga`, `gd`	git modified / new / added / deleted

bash

export EZA_COLORS="di=1;34:ex=1;31:*.md=00;36:*.rs=00;33:gm=33:gn=32"
eza -l --git

Output: (none — exits 0 on success)

For more elaborate styling — per-filekind icons, permission-bit colors, per-extension overrides — switch to the YAML theme.yml described in the Configuration section below. The YAML form is much easier to maintain than a packed environment variable.

Header and machine output

--header (or -h in some builds) prints a column-name header on the first line of long output. The header makes the output self-describing for shared screenshots and pair-programming sessions.

bash

eza -l --header

Output:

sql

Permissions Size User Date Modified Name
.rw-r--r--   12k alice  24 Apr 14:30  Cargo.lock
.rw-r--r--   842 alice  24 Apr 14:28  Cargo.toml
.rw-r--r--  3.4k alice  24 Apr 12:00  README.md
drwxr-xr-x     - alice  24 Apr 14:30  src

For scripts that consume eza output, switch to a strictly machine-readable form. The combination below produces stable, color-free, quote-free output suitable for awk / cut.

bash

eza -l --no-quotes --no-icons --color=never \
       --time-style=long-iso --octal-permissions

Output:

yaml

0644 12k alice  2026-04-24 14:30:00 Cargo.lock
0644  842 alice  2026-04-24 14:28:00 Cargo.toml
0644 3.4k alice  2026-04-24 12:00:00 README.md
0755    - alice  2026-04-24 14:30:00 src

For shell scripts, prefer find -printf (sections/linux/find) or stat -c — eza is designed for humans first.

Recipes

Most recently modified files first

A common need when investigating a build issue: which files changed last? --sort=modified -r (largest mtime first) is the eza equivalent of ls -lt.

bash

eza -l --sort=modified -r --time-style=relative | head

Output:

arduino

.rw-r--r--   80 alice  2 min ago    src/main.rs
.rw-r--r-- 3.4k alice 10 min ago    README.md
.rw-r--r--  842 alice 14 min ago    Cargo.toml
.rw-r--r--  12k alice 14 min ago    Cargo.lock
drwxr-xr-x    - alice 25 min ago    target/

Tree of just source code

Skip build artifacts and dependencies in a tree view by combining -I exclusions with --git-ignore.

bash

eza -T --git-ignore -I 'target|node_modules|.git|dist' --level=3

Output: (none — exits 0 on success)

Audit largest files in a project

--total-size (eza 0.20+) summarizes directory sizes recursively, which ls cannot do at all. Combine with sort and --no-permissions for a compact view.

bash

eza -lah --total-size --sort=size -r --no-permissions --no-user

Output:

csharp

1.2G  24 Apr 14:31 target/
 24M  20 Apr 10:45 node_modules/
8.4M  24 Apr 14:30 .git/
 12k  24 Apr 14:30 Cargo.lock
3.4k  24 Apr 12:00 README.md

Long listing including extended attributes and git

A "tell me everything about this directory" command useful at the start of a code-review session:

bash

eza -lah --git --git-repos -@ --time-style=long-iso --header

Output: (none — exits 0 on success)

One-shot directory diff between two paths

bash

diff <(eza -1 dir-a) <(eza -1 dir-b)

Output: (none — exits 0 on success)

Modern ls replacements compared

eza is one of several Rust/Go-based ls rewrites. Each makes slightly different defaults; the table below summarizes the trade-offs.

Tool	Language	Status	Highlight	Drawbacks
`eza`	Rust	active fork of `exa`	git status, tree, icons, total-size	requires Rust toolchain to build
`exa`	Rust	unmaintained since 2021	same flags as eza	no longer receives fixes
`lsd`	Rust	active	icons by default, friendlier output	no git status, no tree depth column
`colorls`	Ruby	active	git integration, Nerd Font icons	Ruby dependency, slower
`tree`	C	mature	classic recursive tree	no git, no rich metadata
GNU `ls`	C	always available	POSIX baseline	no icons, no git

Reach for eza when you want one tool that does long-format, tree, and git status. Reach for plain ls in scripts you don't control.

Aliases and shell integration

A useful set of aliases beyond the basics — drop them into ~/.bashrc, ~/.zshrc, or Fish's ~/.config/fish/config.fish. The two-letter variants are designed not to clash with the standard ls, la, ll.

bash

# Drop-in replacement
alias ls='eza --color=auto --group-directories-first'
alias l='eza -lah --git --icons --group-directories-first'
alias ll='eza -lh --git --icons --group-directories-first'
alias la='eza -lah --icons'

# Tree shortcuts
alias lt='eza -T --level=2 --icons --git-ignore'
alias lt3='eza -T --level=3 --icons --git-ignore'

# Sort variants
alias lsize='eza -lah --sort=size -r --icons'
alias lmod='eza -lah --sort=modified -r --icons --time-style=relative'

# Audit-style
alias laudit='eza -lah --git -@ --time-style=long-iso --header'

Output: (none — exits 0 on success)

For Fish users, abbr is often a better fit than alias because abbreviations expand visibly before execution:

fish

abbr -a ll 'eza -lh --git --icons'
abbr -a lt 'eza -T --level=2 --icons --git-ignore'

Output: (none — exits 0 on success)

Configuration

eza reads its configuration from $EZA_CONFIG_DIR (defaulting to ~/.config/eza/ on Linux/macOS, %APPDATA%\eza\ on Windows). Two files matter, both introduced in the v0.19 / v0.20 theming overhaul:

theme.yml — color scheme and per-filekind / per-git / per-permission styles in YAML.
config.yml — default flags applied to every invocation (eza 0.21+), so you don't have to repeat them in shell aliases.

yaml

# ~/.config/eza/theme.yml
filekinds:
  directory:  { foreground: "#8a5cff", is_bold: true }
  executable: { foreground: "#ff5e8a" }
  symlink:    { foreground: "#5ec8ff" }
  pipe:       { foreground: "#888888" }
git:
  modified:   { foreground: "#ffaa00" }
  new:        { foreground: "#5fff8a" }
  deleted:    { foreground: "#ff5e8a" }
  renamed:    { foreground: "#5ec8ff" }
permissions:
  user_read:    { foreground: "#5fff8a" }
  user_write:   { foreground: "#ffaa00" }
  user_execute_file: { foreground: "#ff5e8a", is_bold: true }
icon_overrides:
  ".rs":  { glyph: "", color: { foreground: "#dea584" } }
  ".tsx": { glyph: "", color: { foreground: "#5ec8ff" } }

yaml

# ~/.config/eza/config.yml
options:
  long: true
  git: true
  header: true
  icons: auto
  group-directories-first: true
  time-style: long-iso

Place a per-project override by exporting EZA_CONFIG_DIR=./.eza before launching the shell in that directory (a direnv .envrc is a clean way to do this). The eza-community ships a curated eza-themes repository — drop any .yml from there into your config dir as theme.yml to apply it.

Performance notes

eza is fast — typically faster than ls thanks to parallel stat calls — but a few flags are expensive:

--git runs git status machinery per directory; on a tree with many nested repos it adds visible latency. Skip it in ~/.bashrc aliases used in giant directories.
-@ (extended attributes) does extra getxattr syscalls per file. Use only when needed.
--total-size walks each directory recursively. Equivalent to du and just as slow on huge trees.
-T with no --level walks the entire tree. Always cap depth.

Common pitfalls

Mixing --color and --colour — eza accepts both spellings on the command line and in env vars, but EZA_COLORS (American) is the only documented form for the variable. Pick one and stick to it.
Aliasing ls to eza in scripts — POSIX scripts that expect specific ls output break. Either don't alias for non-interactive shells ([ -t 1 ] && alias ls=eza) or use command ls in scripts.
Tree without --level — eza -T on ~ or / walks the entire tree. Always cap depth in muscle-memory aliases.
Icons fall back to boxes — --icons requires a Nerd Font in the terminal. If you see ? or boxes, the font isn't loaded; install JetBrainsMono Nerd Font or another Nerd-patched font.
--git is silent outside a repo — eza prints the status column as -- for every file when there is no .git. Don't mistake that for "everything clean."
macOS access time — macOS records atime in seconds, not nanoseconds, so --sort=accessed may seem coarsely grouped. This is a kernel limitation, not eza.
-h ambiguity — older eza builds use -h for human sizes; newer builds use it for --header. Use the long form (--header, -l's sizes are already human-readable) for portable aliases.

eza --version prints which features were compiled in (+git, +xattr, +selinux). If --git shows no output and you expected status markers, check that the build advertises +git.

Sources

eza-community/eza on GitHub — canonical source, README, and feature list.
eza CHANGELOG.md — version-by-version flag additions (v0.18–v0.23).
eza Releases page — release notes including v0.22.0 (-d rename) and v0.23.0 (--grid TTY behaviour).
eza-community/eza-themes — curated theme.yml files.
eza.rocks — project landing page.
Better Stack: A Look into eza — overview of hyperlinks, themes, and Git integration.
OSC 8 hyperlinks reference — terminal escape-sequence spec used by --hyperlink.
OSC8-Adoption list — which terminal emulators render OSC 8 links.

eza / exa — Modern ls

What it is

Installation

Basic listing

Metadata columns (-l)

Hidden files

Tree view

Git integration

Icons (requires Nerd Font)

Filtering

Sorting options

Colour and display

Hyperlinks (OSC 8)

Absolute paths and symlink following

Aliases to replace ls

eza vs ls equivalents

Classic ls flags vs. eza flags

Tree view in depth

--git deep dive

Extended attributes and ACLs

Filesystem and mount columns

Custom color schemes

Header and machine output

Recipes

Most recently modified files first

Tree of just source code

Audit largest files in a project

Long listing including extended attributes and git

One-shot directory diff between two paths

Modern ls replacements compared

Aliases and shell integration

Configuration

Performance notes

Common pitfalls

Sources

Metadata columns (`-l`)