Eza: A modern, maintained replacement for ls

Nice tip. What got rid of most of my use of `ls` in fish was running `ls` automatically when you changed directories:

  function ls_on_cd --on-variable PWD
      ls
  end

For me, there are two principal cases of sorting in `ls` output: alphabetical when I'm trying to find something I don't know/ remember exactly, and mtime-based when I want to see the latest (or oldest) in a group of related files. I don't see how it could work with one shortcut.

Another thing is `ls -l` that's important when I need to understand file sizes and especially how symlinks are set up. Yet another is `ls -ld` which explains details about directories.

All these cases could be made more ergonomic, and maybe partly merged. But I don't see how I could compress them into one type of output that fits all purposes.

(My current fancy version of `ls` is `lsd`, but I still use the built-in `ls` a lot.)

I cannot find this shortcut in https://fishshell.com/docs/current/interactive.html.

Do you know where it's documented by any chance?

Also many shells come with greatly improved ls implementations built in, like that of nushell.

I just use bash and tab tab all the time.

Bash users: FYI you can bind shortcuts like this, too. I have my right hand home row keys bound to __bash_ctrl_n() (for e.g.), and various tools in my dotfiles override these functions (git, if installed, sets up __bash_ctrl_e() to run git status and git log).

In bash/zsh you can easily setup fzf completions ctrl-r (for directory) and ctrl-t (for shell history)

TIL! great tip, thanks. Now I just need to wire that shortcut up to `lsd` instead of `ls`.

Update: the ls command is stored at __fish_ls_command, so this is a `set -g __fish_ls_command lsd` in `config.fish`.

I just use mc and ctrl-O, to switch between shell and listing.

I realized most of my ls runs come right after `cd`, so I added these to my startup files. Now almost every `cd` does `ls` automatically:

    # bash, simple
    function cd() {
        builtin cd "$@" && ls -l
    }

    # fish, a bit more sophisticated
    function cd

        builtin cd $argv;
        if test $status -gt 0  # there was an error, stop
            return
        end

        # auto print dir info
        if test "$argv" != ""  # not home though
            dir  # aka ls -l ...
        end
    end

history? atuin has been great.

And also results in a cleaner shell history

In Bash you can also keep the history cleaner by adding ls (or other commands) to the HISTIGNORE env var: https://superuser.com/questions/232885/can-you-share-wisdom-...

I have been using fish for a long time and I didn't know about this. Thanks.

This appears to run eza for me, probably because I've aliased ls to eza. So I'm guessing it's just running `ls`.

I agree. GitHub does this too on commits. "foo.cpp modified last year." It makes no sense, at least without the ability to view additional datetime information.

This is a setting, you can change it to any other date format you want.

Yeah that is such an amazing anti-feature. And how do you deal with changes? Like, when does 1 day ago become 2 days ago? According to google it becomes two days ago after 48 hours. That means if you look at your phone after 47 hours it will say 1 day ago and you'll be tricked into it happening yesterday. Human readable my ass.

Or, you know the specific day because it was the day after your friends birthday or whatever. And you try to find a specific item, but you have to sift through an entire months of shit because all the information you get is "three months ago".

You can hover over the time on HN and get a timestamp.

I wonder if sites could use the HTML <time> tag for this. They could choose the human readable format but still give us the time so that it could be replaced or overlayed with some extension.

I always try to use it when writing HTML.

(https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ti...)

One thing I really like about all of the ago formats:

- What it says: 1 year ago

- What it is: 1 year and 10 months ago

Yes, I hate that approach too. I think it started with either Web 2.0 startups (I was working with one at the time, that implemented that in their product), or with Google and suchlike companies around that time, in their general web apps or social media web apps.

I agree, they should provide the detailed time, then provide the days ago thing too, if they want to.

4 additional tools I use regularly:

- task, a Makefile alternative

- hyperfine, a benchmark tool

- vegeta, a load testing tool

- sd, a better, more intuitive sed

There’s also the JSON trinity:

- jq, the well know JSON processor

- jc, convert the output of many CLI tools to JSON

- gron, make JSON greppable

I didn't find zellij to be better than screen. The tabs/screens are not numbered correctly so switching directly to them requires manually counting. A non-starter for me.

This link also has a large list of additional tools I hadn't heard of but look interesting.

https://github.com/ibraheemdev/modern-unix

I use du-dust over gdu, but otherwise my list is almost identical to yours.

Gotta love Rust (in which most if not all of these tools are written).

As someone who defaults to lsd, is there any reason why you prefer eza to it?

Great list! I would also add:

   viddy, a replacement for watch that includes history

If tooling would simply use the Base16 Framework[0] instead of arbitrary colors from “256 color” or “RGB” color modes, this would be much less of a problem: the output would always be displayed with (presumably) readable colors defined by your terminal.

[0] https://github.com/chriskempson/base16

[1] https://tinted-theming.github.io/base16-gallery/

Solarized is easy on the eyes and the colours are chosen for readability.

https://ethanschoonover.com/solarized/

The list on the site lacks some entries. Konsole has it built in and i bet Gnome Terminal too.

I'm totally the other way around, I rely on colorized output heavily.

But! There's supposed to be a solution to this, set $NO_COLOR to some value. https://no-color.org

Totally reasonable to file a bug report against tools which don't check and respect that env variable.

30-odd years of using ls and this comment is finally the catalyst for me to start using -A instead of -a. Thank you!

--color=never

You can use vivid [1], choose a proper theme that works for your terminal background and load the generated LS_COLORS variable into your shell.

[1]: https://github.com/sharkdp/vivid/

https://no-color.org

I work on VS Code. We have a feature for this exact problem that enforces a minimum contrast ratio of 4.5:1 via shifting the luminance of the foreground text by default https://code.visualstudio.com/docs/terminal/appearance#_mini... . This feature's in xterm.js so any terminal based on xterm.js can leverage this.

We actually got a bit of push back when this was released but I haven't heard anything for quite a while now that some time has passed and we have a FAQ for colors not being "correct".

I think they are not referring to ls, but to exa [0], which is not maintained anymore.

[0]https://github.com/ogham/exa

For some reason it became the norm to think that if some piece of software isn't updated regularly that it's inherently out of date.

Because he's deliberately confusing "maintained" with "actively developed" in order to insinuate that the existing tools is unmaintained.

Of course `ls` is maintained, as a part of your shell or of coreutils.

But `eza` is a variation of `exa`, and the latter is no longer maintained, AFAICT.

Professional Linux masters just use the `echo *` shell built-in

I’ve had eza (and formally exa) aliased as ls, ll and lll since around 2015 and never hit a compatibility issue.

I also have sl installed to encourage accuracy when running it…

You can alias it to whatever you want though.

`command -v eza >/dev/null && alias ls="eza"`

This is where an azerty keyboard shines.

this was my first reaction too

I was a former exa user, and the z is next to x on my keyboard, wasn't a huge hassle for me

Can you elaborate on why aliasing is kind of weird?

As a Dvorak user, ‘eza’ seems like an improvement! (‘ls’ on a Dvorak layout is ‘p-’ on QWERTY; both keys on the right little finger.)

No the maintained here means it is a maintained (replacment) with reference that it is a fork of exa which was a ls replacment that is not maintained anymore. It does not say that ls is not maintained.

This is referencing 'exa', of which eza is a fork. Exa was unmaintained for about a year before it was marked officially deprecated by the only person with write permissions on the repository.

It has definitely been long enough now since the forking, where not everyone is aware of exa, and this language/intent is now far less clear. I see you are not the only one to comment on this, so I think it's time to update the phrasing.

Challenge: which of the letters a to z and A to Z are NOT switches that modify the behavior of ls?

I would guess that ls has at least 50 different behaviors based on the switches.

emphasis on community building

Probably the first time ever I hear about a community built on a freaking directory listing tool.

ls is the archetypical example of unix gone wrong, and I think this was already widely discussed (and joked) about in early 90s (iirc unix haters had something about that). It should be just simple wrapper for readdir, but it grew into sprawling mess when it learned to stat the files too, which snowballed ls to have gazillion ways to handle all sorts of metadata

eza's scope is much larger than ls's, and has tons of additional features.

And IMO, that's sensible: ls is primarily an interactive tool (basically all uses of it in shell scripts are wrong), so adding more features that help users to better/more easily make sense of their directory listings is a net benefit, even if it makes the tool somewhat slower.

Folder icons in the terminal may sound silly, but eza uses them to indicate empty folders, among others. Colour-coded file age/size columns make parsing a directory list faster. Git columns saved my many trips through gitignore / git status. And so on.

And even through not particularly fast fuse-over-network connections it's still faster than I can type, which is more than good enough for an interactive CLI tool.

The only time you have to care about GNU tools vs your own preference of tool is when writing scripts to run on computers running some Linux distributions, and per [1] you shouldn’t be using ls for that.

[1]: https://www.shellcheck.net/wiki/SC2045

Use cases are different. I bet I'm not the only one who runs ls manually on my command line a LOT more than I ever use it in scripts.

I don't know how common my situation is, but I don't have any of those constraints. I have eza aliased to ls both on my daily driver and all of my work servers and it hasn't caused me a single problem.

The GNU project didn't invent ls. The GNU coreutils (including ls) were originally new versions of either proprietary (AT&T) or BSD licensed utilities.

Related: https://github.com/uutils/coreutils "Cross-platform Rust rewrite of the GNU coreutils"

Rust users tend to permissively-license their code in general. I don't know if there are easily available statistics but almost everything on the Rust package repository (crates.io) is MIT or Apache-2.0; certainly the most popular libraries are.

Totally —- any idea why eza claims exa doesn’t support it? I know that’s wrong.

contributions welcome

eza features not in exa (non-exhaustive):

It at least mentions it's existence (though no link or context)

https://github.com/orgs/eza-community/discussions/679#discus...

I've used both, but settled on using `lsd`. While eza has slightly better performance, that difference doesn't usually matter for a `ls` alternative (unless you operate on very large directories) and `lsd` is nicer and feature rich.

I keep `ls` un-aliased precisely because of this. I do keep these two aliases around:

    alias l="eza --all"
    alias ll="eza --long --all --time-style=long-iso --group"

Yeah that one's annoying.

I got used to a "recent" alias (Zsh):

  if (( $+commands[eza] )) {
    alias recent="eza --binary --octal-permissions --no-permissions --git -snew --icons=always"
  } else {
    alias recent="ls -rt"
  }

À la powershell’s Get-ChildItems!

It’s a good point, as the shell glob syntax is too limited.

You can get something similar with shell globs, and ~not in zsh. e.g. *~*.c(.) to exclude all .c files (and only list files, not directories or anything else).

Looks a bit obscure at a glance due to lack of spaces, but it's not that different from -exclude or "| grep -v".

Why is why I’ll never be using any of these as the default.

ls works, is not mission critical (you know what I mean), and will always be around.

eza -l --time-style=+%Y%m%d --no-user --no-permissions

It’s not saying that ls is not maintained.

I use the --color=always option with eza. This allows it to be piped through less and still maintain the color.

To avoid having to type that option every time, I have a bash alias for ls:

  alias ls='eza -F --color=always'

`alias ls = "exa"`

Problem solved.