The 'ls' Command Is Obsolete

Why Your Terminal Is Stuck in the Past

Type `ls` in a terminal today and you are effectively time-traveling back to the 1970s. The command still does what it always did—dump a directory listing—but modern development workflows demand far more than a monochrome column of filenames. Your editor, browser, and IDE evolved; your file lister largely did not.

Traditional ls knows nothing about Git, even though virtually every serious project lives in a repository. You cannot glance at a directory and see which files are modified, ignored, or untracked without running separate `git status` commands. That means constant mental context switching: `ls` to see files, `git` to see state, your brain to stitch it together.

Visual feedback is just as primitive. GNU ls can colorize output, but it stops at basic file types and permissions, with no concept of icons, clickable paths, or gradients that highlight large or recent files. You get no: - Git-aware indicators - Per-file icons - Hyperlinks you can click in modern terminals

Information density is another problem. A long `ls -l` dump crams permissions, owners, sizes, and timestamps into a wall of text that scales poorly once a directory has hundreds of entries. You either see too little (`ls`) or way too much (`ls -l`), with no nuanced middle ground like “only directories,” “hide Git-ignored files,” or “show directories first.”

Meanwhile, your terminal has become your primary UI as tools like Git, Docker, and Kubernetes push more workflow into the command line. You jump between Linux and macOS, juggle dozens of repos, and still rely on a file lister designed before version control was mainstream. Why doesn’t your directory view understand your VCS, your fonts, or your color scheme?

So what would a file listing tool look like if it were designed for 2025 instead of 1975? What if `ls` could show Git status inline, add icons automatically, and use smart sorting and filtering flags that match how you actually work? That gap—between what `ls` offers and what developers now expect—is exactly where eza steps in.

Meet Eza: The Successor to a Legend

Command-line traditionalists may not like hearing it, but eza is the tool that behaves the way people expect `ls` to behave in 2025. It ships with sane defaults, color by default, and a layout that surfaces what actually matters: file types, Git status, and human-readable metadata, instead of a monochrome wall of text. Written in Rust, it leans on memory safety and aggressive parallelism to stay fast even in giant repositories.

Eza didn’t appear out of nowhere. It started as a community-maintained fork of exa, the beloved Rust `ls` replacement created by Benjamin Sago (known as “ogham”) that went unmaintained for years. When exa stalled, contributors moved the codebase to the eza-community/eza repo, cleaned up long-standing issues, and began shipping frequent releases for Linux and macOS.

Origin aside, eza’s pitch is simple: better defaults, richer information, and a developer-first experience. Run `eza -l --git` and you immediately see Git-aware markers like `M` for modified, `N` for new, and `I` for ignored files in the same listing as permissions and sizes. Add `--git-repos` and directories turn into a dashboard of branches and “dirty/clean” status across multiple repos.

Visual signal density is where eza pulls away from `ls`. Colors are always on in interactive use, and flags like `--colour=always` preserve them through pipes, while `--colour-scale` uses gradients to highlight large or recent files. With a Nerd Font installed, `--icons` decorates each entry with file-type glyphs, and `--hyperlink` turns paths into clickable links in terminals that support it.

Developer ergonomics show up in the sorting and filtering model. Instead of memorizing arcane `ls` flag combos, you get explicit options such as: - `--sort=size`, `--sort=time`, or `--sort=extension` - `--reverse` for inverted order - `--group-directories-first`, `--only-dirs`, or `--only-files`

Alternatives exist, but eza targets them directly. The project explicitly claims to be faster than lsd, another Rust `ls` clone, while offering deeper Git integration, theming via config files, tree views with `--tree`, and compatibility shims so you can alias `ls` or even `exa` to eza and forget the switch ever happened.

Installation and Your First Alias

Modern macOS machines make installing eza almost trivial. With Homebrew set up, run: - `brew install eza` That single command pulls a prebuilt Rust binary, adds it to your PATH, and gives you updates via `brew upgrade eza` whenever the project ships a new release.

Linux users get similar treatment. On Debian/Ubuntu, run `sudo apt install eza` (on older releases you may need the GitHub .deb). On Arch and derivatives, `sudo pacman -S eza` installs from community repos. Other distributions either package it under `eza` or document instructions on eza – A modern alternative to ls (Official GitHub).

To make eza feel invisible but omnipresent, alias it to ls. Add this line to your shell config: - Bash: add `alias ls='eza'` to `~/.bashrc` - Zsh: add `alias ls='eza'` to `~/.zshrc` After editing, reload with `source ~/.bashrc` or `source ~/.zshrc`, or just open a new terminal tab.

First run `eza` with no flags. You immediately get color-coded, column-aligned output that respects terminal width better than `ls`. Hidden files stay hidden by default, which keeps noisy project roots readable.

Next, try `eza -l`. The long view adds permissions, owners, sizes, and timestamps in a more legible layout, with colors separating metadata from filenames. Then run `eza -a` to include dotfiles; you still get a clean, color-sorted list instead of the visual soup `ls -a` usually produces.

If your alias does nothing, you likely edited the wrong file or your shell loads a different config. Check `$SHELL` to confirm Bash vs Zsh, ensure the alias line has no stray spaces or quotes, and run `type ls` to verify it now points to eza. When in doubt, restart the terminal to force a clean environment.

Unleash Git, Directly in Your File Listings

Git-aware file listings stop you from alt-tabbing to `git status` every 30 seconds. With eza, Git is not a separate step; it’s baked right into the directory view so your working tree health sits beside file names, sizes, and timestamps.

Run `eza -l --git` in any repository and you get an extra status column straight from Git. Each file shows a concise marker pulled from `git status --short`, so you can scan for trouble without parsing a wall of text.

Those tiny letters carry a lot of meaning. In long format, eza uses:

• `M` on the left: modified and staged
• `M` on the right: modified but not staged
• `N`: new, untracked file
• `I`: ignored by `.gitignore` or `.git/info/exclude`

Because these markers sit per line, you immediately see which files are safe, which are half-committed, and which are still wild. No more guessing which `src/` change you forgot to add before your last commit.

Large monorepos multiply that value. With `eza --git --tree --level=2`, you can walk a project hierarchy and keep Git status in view at every depth. That combination turns a plain tree view into a live map of uncommitted work.

Repository sprawl creates a different problem: knowing which project is clean before you push. The `--git-repos` flag tackles exactly that. Point eza at a directory full of projects and it summarizes each Git repo in a single line.

For every subdirectory that contains a `.git` folder, `eza --git-repos` shows the current branch, plus a “dirty” or “clean” indicator. You can glance at 10 or 50 repos at once and instantly spot the one with unpushed or uncommitted changes.

Noise from generated assets and logs can bury the signal in big codebases. Add `--git-ignore` and eza hides anything Git already ignores, effectively applying your `.gitignore` rules to the file listing itself. Node `dist/`, Python `.venv/`, `coverage/` reports, and build artifacts vanish from view.

Combine these flags and the terminal becomes a Git dashboard: `eza -l --git --git-ignore --group-directories-first` for focused editing, or `eza --git-repos ~/code` for a portfolio-wide status check. Old `ls` shows files; eza shows the actual state of your work.

Beyond Black and White: A World of Color

Color is where eza stops pretending to be a drop‑in replacement and starts feeling like a modern UI squeezed into a terminal. Out of the box, it ships with an intelligent default palette that encodes file types, permissions, and metadata at a glance: directories in one hue, executables in another, symlinks in a third, with extra accents for things like sticky bits and world‑writable paths. You don’t configure anything; you just run `eza` and your filesystem suddenly has a legend.

Traditional `ls --color` feels crude by comparison. Eza’s defaults distinguish not only what a file is, but also how safe it is to touch. Suspicious permission combos, like group‑writable binaries, stand out immediately, acting as a low‑friction security audit every time you list a directory.

Color gets even more important the moment you start piping. Many tools strip ANSI codes unless you explicitly tell them not to, so eza exposes `--colour=always` to force persistent color output. That one flag keeps your hues alive through `grep`, `less -R`, `fzf`, or even into log files you tail later.

Used together, the pattern looks like this: - `eza --colour=always | less -R` - `eza --colour=always | grep pattern` - `eza -l --git --colour=always | fzf`

Where eza really pulls away from `ls` is `--colour-scale`, a feature that turns raw metadata into a visual gradient. With `--colour-scale=size`, large artifacts—think multi‑gigabyte VM images or bloated node_modules—light up differently from tiny config files. Switch to `--colour-scale=age` and yesterday’s edits glow against a backdrop of untouched legacy cruft.

Those gradients scale especially well in big trees. Run `eza --tree --colour-scale=size` on a project and you can spot the 3–4 files eating disk without reading a single number. It feels closer to a heatmap than a dumb listing.

If you dislike the defaults, eza doesn’t trap you. It supports custom color themes, loaded from configuration files that map semantic roles (directory, symlink, socket, git‑modified) to specific styles. You can grab a community theme from eza-community/eza, drop it into your config, or build your own so every terminal you touch feels unmistakably yours.

Master the View: From Grids to Trees

Grid view is where eza starts. By default, it packs filenames into a multi-column grid, using your terminal width to avoid the ragged, single-column mess you often get from ls. You still get colors, icons, and Git markers in this view, so a bare `eza` is already more informative than `ls -F`.

When you need details, long view is the workhorse. `eza -l` switches to a long listing with permissions, owners, groups, sizes, timestamps, and optional Git status in a clean, aligned table. Combine `-l` with `-a` to expose dotfiles or with `--group-directories-first` to keep folders at the top of the stack.

Sometimes you want density, not decoration. `eza --oneline` prints one entry per line, ideal for scripting, piping into `fzf`, or eyeballing massive directories without horizontal scrolling. Add `--sort=size` or `--sort=modified` to turn that into a quick visual report of your biggest or newest files.

Developers gravitate to `eza --tree`. The tree view recursively walks directories and renders a full hierarchy with box-drawing characters, icons, and colors, so nested `src`, `tests`, and `migrations` directories become instantly legible. Run `eza --tree src` in a JavaScript or Rust repo and you get a project map that beats any `ls -R` wall of text.

Tree output can explode on real-world monorepos, so eza ships a sharp brake: `--level`. Use `eza --tree --level=2` to see just the top two layers of a Node workspace, or `--level=4` to peek deeper into `packages/` without drowning in `node_modules`. That depth cap turns `--tree` from a novelty into a daily driver for navigating complex structures.

For more control, eza exposes a handful of focused display toggles. `--header` adds a header row to long listings, labeling columns like permissions, size, and modified time, which is perfect when you screenshot output for docs or bug reports. `--inode` shows inode numbers, invaluable when you debug hard links or weird filesystem behavior.

Power users can stack these flags. A command like `eza -la --header --inode --tree --level=2` gives you a richly annotated, two-level project overview in one shot. For deeper reading on these modes and more examples, eza: Simplifying File Listing with Improved 'ls' Functionality – Linuxiac breaks down additional combinations and edge cases.

Command Your Data: Sorting and Filtering Like a Pro

Command-line power users live and die by sort order. Eza treats sorting as a first-class feature with a single, consistent `--sort` flag instead of `ls`’s grab bag of options. You can sort by size (`--sort=size`), modified time (`--sort=modified` or `--sort=mtime`), created time (`--sort=created` or `--sort=ctime`), name (`--sort=name`), or extension (`--sort=extension`).

Where `ls` scatters behavior across flags like `-t`, `-S`, and `-X`, eza collapses it into readable, script-friendly arguments. Need largest artifacts at the top of your build directory? `eza --sort=size --reverse target` surfaces the biggest offenders instantly.

Reversing a sort exposes one of the most important differences from `ls`. Instead of separate reverse variants like `-tr` or `-Sr`, eza always uses the same `--reverse` flag. You specify what to sort by, then flip it: `eza --sort=modified --reverse` means “oldest first,” no mental gymnastics required.

That design choice pays off when you chain options. A long Git view of your repo, with newest changes on top, becomes `eza -l --git --sort=modified`. Want the same list but with the oldest cruft you should probably delete? Add `--reverse` and nothing else changes.

Sorting only gets you halfway; serious projects need filtering. Eza ships `--group-directories-first`, which pushes folders to the top of the listing without weird locale hacks or shell tricks. Combine it with `--sort=name` for a clean, predictable layout in any language.

When you need to narrow the noise, `--only-dirs` and `--only-files` act like surgical filters. Scan just your directory structure with `eza --only-dirs --group-directories-first --tree`, or inspect only compiled binaries and assets using `eza --only-files --sort=size`. No `find` incantations required.

These flags start to feel like query operators once you stack them. Common real-world combos include: - `eza --group-directories-first --sort=extension --only-files src` - `eza -l --sort=created --reverse --only-files dist` - `eza --sort=modified --only-dirs --git`

That last command shows only directories, sorted by recent activity, with Git status integrated—a live heat map of where your work actually happens.

Your Terminal, Now with Icons and Hyperlinks

Icons turn eza from a smarter `ls` into something that actually feels modern. Add `--icons` to any command and file listings suddenly gain tiny, high-signal glyphs: a Python logo for `.py`, a document icon for `.md`, a gear for executables, distinct symbols for symlinks and hidden files. Directories get folder icons, and Git repos stand out instantly when combined with `--git` and `--git-repos`.

Those icons depend on Nerd Fonts, a popular project that patches developer-friendly typefaces with thousands of extra glyphs. Nerd Fonts bundles symbols from projects like Font Awesome, Devicons, and Octicons into more than 50 base fonts. You are not installing a plugin for eza; you are installing a font that your terminal can render.

On macOS, a typical setup takes three steps. Download a Nerd Font such as FiraCode Nerd Font or JetBrainsMono Nerd Font from nerdfonts.com, install it by double-clicking and hitting “Install Font,” then point your terminal at it. Linux users can often install via package managers (`sudo pacman -S nerd-fonts-jetbrains-mono`, for example) and then select it in their emulator’s preferences.

Configuring iTerm2 is straightforward. Open Preferences → Profiles → Text, click the font selector, and choose your installed Nerd Font (regular and non-ligature variants both work). After that, `eza --icons` immediately shows language logos, archive icons for `.zip` and `.tar.gz`, database icons for `.sql`, and more.

Kitty users edit `kitty.conf` directly. Set a line like `font_family JetBrainsMono Nerd Font` and restart Kitty or reload the config. Because Kitty speaks modern Unicode cleanly, icons render crisply, with no misaligned columns or broken box characters.

Visual density jumps, but cognitive load drops. When you run something like `eza -l --git --icons`, your eye can skim for: - Folder icons to track directory structure - Repo icons to spot Git roots - Language icons to find `.ts`, `.rs`, `.go` at a glance

Hyperlinks push eza even further into GUI territory. With `--hyperlink`, eza emits OSC 8 escape sequences that many modern terminals understand as clickable links. Filenames become URLs pointing to `file://` paths, so clicking them can open Finder on macOS, your file manager on Linux, or an editor that registers as a handler.

Support varies by emulator, but iTerm2, Kitty, and recent GNOME Terminal builds handle these links reliably. Combine `--hyperlink` with `--icons --long --git` and you get a dense, clickable, visually coded dashboard of your working directory—all from a single command.

Eza vs. The Old Guard: ls, exa, and LSD

Old-school ls still ships on every Unix-like system, but its feature set stalled decades ago. No colors by default, no Git awareness, no icons, and no hyperlinks. You can bolt on aliases and LS_COLORS, yet you still juggle flags that vary between GNU coreutils, BSD, and macOS.

Modern replacements split into three camps: exa, lsd, and eza. All three target nicer defaults, color, and better metadata. Only one of them, though, is aggressively maintained in 2024.

Quick feature snapshot:

• ls: C, ubiquitous, minimal features, no Git, no icons
• exa: Rust, archived on GitHub, color, basic Git, some tree support
• lsd: Rust, opinionated icons and colors, no deep Git, slower feature velocity
• eza: Rust, active community, Git-heavy, icons, hyperlinks, trees, theming

Core differentiator: exa is effectively frozen. Its GitHub repo sits archived, with open issues and unmerged PRs piling up. Eza started as a fork, but the eza-community maintainers rewired it into a fast-moving project with frequent releases, modern flags, and distro packages landing quickly.

Performance stays sharp across the Rust trio. Benchmarks from users show eza and lsd running directory listings in tens of milliseconds on medium trees, typically beating GNU ls once you enable comparable color and classification flags. Eza leans on Rust’s async-friendly ecosystem and tight syscalls to keep latency low, even when `--git` or `--tree` walk entire repos.

Feature depth is where eza pulls ahead. You get `--git`, `--git-repos`, `--git-ignore`, `--colour-scale`, `--icons`, `--hyperlink`, `--only-dirs`, and `--sort` with fields like `size`, `modified`, `created`, and `extension`. Lsd focuses on pretty defaults and icons but skips advanced Git metadata; exa exposes some Git info but misses newer flags and bugfixes eza added.

Ecosystem and docs seal the deal. Eza ships in Homebrew, major Linux repos, and has detailed man pages plus community themes and config snippets. For a deeper breakdown, Transform Your Terminal with eza: The Upgrade ls Deserved – DEV Community walks through practical setups and aliases.

Taken together, active development, Rust performance, and a Git-first feature set make eza the most capable `ls` replacement you can install in 2024.

Crafting Your Ultimate Eza Workflow

Start with aliases. Most people wire `eza` into muscle memory with a few high‑leverage shortcuts in `~/.zshrc` or `~/.bashrc`:

• `alias ll="eza -l --group-directories-first --git --icons"`
• `alias la="eza -la --group-directories-first --git --icons"`
• `alias lt="eza --tree --level=2 --long --git --icons"`
• `alias l1="eza --oneline --sort=name"`
• `alias lg='eza -l --git --git-ignore --group-directories-first'`

Those five cover 90% of day‑to‑day listing: detailed, all‑files, tree, single‑column, and Git‑aware views.

Next, craft a personal default and bind it to `ls` itself. A lot of developers do:

- `alias ls="eza --group-directories-first --icons --git --header"`

From there, add flags that match your workflow: `--all` if you live in dotfiles, `--binary` if you care about human‑readable sizes, or `--colour-scale=size` if you constantly hunt large artifacts in `dist/` or `node_modules/`.

Power users stack multiple behaviors into specialized views. Examples:

• `alias lcode='eza -l --git --git-ignore --sort=modified --group-directories-first src tests'`
• `alias lbig="eza -l --sort=size --reverse --colour-scale=size"`
• `alias lrecent='eza -l --sort=modified --reverse --colour-scale=age'`
• `alias ldirs="eza --only-dirs --group-directories-first --tree --level=3"`

Those compress complex intent—“show me recent code changes” or “surface the biggest files”—into 5–6 characters.

Customization does not stop at flags. Eza supports themes, so you can drop a community theme into the config directory (see GitHub) and switch instantly, or hand‑tune colors for permissions, symlinks, and Git states using the theming guide. Combine that with Nerd Fonts, `--hyperlink`, and `--icons` to turn your terminal into a dense, navigable dashboard.

Now your turn: post your sharpest `eza` aliases, theme setups, and weird one‑liners in the comments. Someone else’s three‑flag trick might become your new default.

Frequently Asked Questions

What is eza?

Eza is a modern, feature-rich command-line utility that replaces the traditional 'ls' command. Written in Rust, it offers better performance, color-coded output, Git integration, file icons, a tree view, and more.

Is eza a direct, drop-in replacement for 'ls'?

Mostly, but not entirely. While you can alias 'ls' to 'eza' for daily use, some flags and sorting behaviors differ. For example, reversing a list by time requires a different flag combination in eza compared to ls.

How do I install eza?

You can install eza using package managers like Homebrew for macOS (`brew install eza`) or your distribution's package manager for Linux (e.g., `sudo apt install eza`).

Why do I need a Nerd Font to use icons with eza?

Nerd Fonts are special fonts patched with a large number of glyphs and icons. Eza uses these icons to represent different file types and folders, so a Nerd Font must be installed and configured in your terminal to render them correctly.