Eza vs Exa

Detailed comparison of features, pros, cons, and usage

eza-community/eza is a community-driven fork of ogham/exa that aims to provide more frequent updates and additional features, while ogham/exa is the original, more stable project with a slower development pace, making eza potentially more feature-rich but possibly less stable compared to exa.

Eza

A modern alternative to ls

16,069

Exa

A modern replacement for ‘ls’.

24,005

Eza Pros and Cons

Pros

Modern Rust implementation: Offers improved performance and memory safety compared to traditional Unix tools.
Feature-rich: Provides numerous options for customizing output and displaying file information.
Active community: Regularly updated with new features and bug fixes, ensuring ongoing support and improvements.
Cross-platform compatibility: Works on various operating systems, including Linux, macOS, and Windows.

Cons

Learning curve: May require users to familiarize themselves with new flags and options compared to traditional ls command.
Dependency on external libraries: Requires additional Rust libraries, which could potentially introduce vulnerabilities or compatibility issues.
Larger binary size: The executable is typically larger than the standard ls command, which may be a concern for systems with limited storage.
Potential for feature bloat: The extensive feature set might lead to unnecessary complexity for users who prefer simpler tools.

Exa Pros and Cons

Pros

Modern replacement for ls: Offers a more feature-rich and visually appealing alternative to the traditional ls command.
Colorful and informative output: Provides color-coded and detailed file information, making it easier to distinguish between different file types and permissions.
Git integration: Displays Git status for files and directories, which is particularly useful for developers working with version-controlled projects.
Customizable: Allows users to configure various display options and color schemes to suit their preferences.

Cons

Dependency on Rust: Requires Rust to be installed for compilation, which may be an extra step for some users.
Learning curve: Users familiar with ls may need time to adapt to the new flags and options provided by exa.
Slower than ls for large directories: Performance can be slightly slower compared to ls when listing contents of directories with a large number of files.
Not pre-installed on most systems: Requires manual installation, unlike ls which comes pre-installed on most Unix-like systems.

Eza Code Examples

Basic Usage

This snippet demonstrates the basic usage of eza to list files with extended attributes:


eza -la


eza -la --git


eza --tree --level=2

Customizing Output

Here's an example of customizing the output format and colors:


eza -l \
    --color=always \
    --time-style=long-iso \
    --group-directories-first \
    --git \
    -I '.git|node_modules'

Sorting and Filtering

This snippet shows how to sort and filter files:


eza -l \
    --sort=size \
    --reverse \
    --only-dirs


eza -l \
    --sort=modified \
    -I '*.log' \
    --modified-before '1 week ago'

Exa Code Examples

Basic Usage

The following snippet demonstrates basic usage of exa, showing how to list files with extended details:


exa -l


exa -la --icons


exa --tree --level=2

Customizing Output

This snippet showcases how to customize the output of exa using various options:


exa -l --git --bytes


exa -D --sort=size --reverse


exa -l --time-style=iso --color=always --group-directories-first

Eza Quick Start

Installation

Using a package manager

Install eza using your system's package manager:

# macOS (Homebrew)
brew install eza

# Arch Linux
pacman -S eza

# Debian/Ubuntu
sudo apt install eza

Building from source

Ensure you have Rust installed. If not, install it from rustup.rs.

Clone the repository and build the project:

git clone https://github.com/eza-community/eza.git
cd eza
cargo build --release

Copy the binary to a directory in your PATH:

sudo cp target/release/eza /usr/local/bin/

Basic Usage

Once installed, you can start using eza as a modern replacement for ls. Here are some basic examples:


eza


eza -l


eza -a


eza --tree


eza -l --sort=size

For more advanced usage and options, refer to the eza --help command or the project's documentation.

Exa Quick Start

Installation

Using package managers

For macOS (using Homebrew):
```
brew install exa
```
For Arch Linux:
```
pacman -S exa
```
For other systems, check the official installation guide for more options.

Building from source

Ensure you have Rust installed. If not, install it from rustup.rs.

Clone the repository and build:

git clone https://github.com/ogham/exa.git
cd exa
cargo build --release

Move the binary to your PATH:

sudo mv target/release/exa /usr/local/bin/

Basic Usage

Once installed, you can start using exa as a modern replacement for ls. Here are some basic examples:

List files in the current directory:
```
exa
```
List files with detailed information:
```
exa -l
```
Show hidden files:
```
exa -a
```
Display files as a tree:
```
exa --tree
```
Sort files by modification time:
```
exa -s modified
```

For more advanced usage and options, refer to the exa --help command or the official documentation.

Top Related Projects

lsd

14,477

The next gen ls command

Pros of lsd

Colorful and visually appealing output with icons
Supports tree view for directory structure visualization
Faster performance in some scenarios

Cons of lsd

Less feature-rich compared to eza and exa
Limited customization options for output format
Smaller community and fewer contributors

Code Comparison

lsd:

pub fn get_icon(file: &File) -> &'static str {
    match file.file_type() {
        FileType::Directory => "",
        FileType::SymLink => "",
        _ => get_file_icon(file),
    }
}

eza:

pub fn icon(file: &File) -> Option<char> {
    match file.type_() {
        Type::Directory => Some(''),
        Type::SymLink => Some(''),
        _ => file_icon(file),
    }
}

exa:

pub fn icon(file: &File) -> Option<char> {
    match file.type_() {
        Type::Directory => Some(''),
        Type::Symlink => Some(''),
        _ => file_icon(file),
    }
}

The code snippets show similar approaches to handling file icons, with lsd using string literals and eza/exa using char types. eza and exa have nearly identical implementations, while lsd's structure differs slightly.

logo-ls

1,174

Modern ls command with vscode like File Icon and Git Integrations. Written in Golang

Pros of logo-ls

Unique feature: Displays colorful icons for different file types
Lightweight and focused on visual enhancements
Easy to install via Go package manager

Cons of logo-ls

Less feature-rich compared to eza and exa
Limited customization options
Smaller community and less frequent updates

Code Comparison

logo-ls:

func (f *File) GetIcon() string {
    icon := icons.GetIcon(f.Name, f.IsDir())
    return icon
}

eza:

fn colour_file(&self, file: &File<'_>) -> Style {
    if file.is_directory() {
        self.theme.directory
    } else {
        self.theme.file(file)
    }
}

exa:

fn colour_file(&self, file: &File) -> Style {
    if file.is_directory() {
        self.directory
    } else {
        self.file(file)
    }
}

The code snippets show how each project handles file icons or colors. logo-ls focuses on icon retrieval, while eza and exa emphasize color styling for different file types. eza and exa have similar approaches, reflecting their shared codebase, while logo-ls takes a distinct approach with its icon-centric design.

dust

10,022

A more intuitive version of du in rust

Pros of dust

Specialized for disk usage analysis, providing a more focused tool
Offers a visually appealing and interactive interface for exploring disk usage
Supports excluding specific files or directories from analysis

Cons of dust

Limited to disk usage analysis, lacking the broader file listing features of eza and exa
May have a steeper learning curve for users accustomed to traditional command-line tools
Less frequent updates compared to eza and exa

Code Comparison

dust:

pub fn get_dir_tree(path: &Path, config: &Config) -> DirTree {
    let mut dir_tree = DirTree::new();
    dir_tree.set_root(path);
    dir_tree.set_apparent_size(config.apparent_size);
    dir_tree
}

eza:

pub fn list(options: &Options, args: &[String]) -> i32 {
    let mut files = Vec::new();
    for arg in args {
        files.extend(options.filter.list_dir_contents(arg));
    }
    display_files(options, &files)
}

exa:

pub fn run(options: &Options) -> i32 {
    let mut files = Vec::new();
    for file in options.files.iter() {
        files.extend(file.to_files());
    }
    display_files(options, &files)
}

delta

26,562

A syntax-highlighting pager for git, diff, grep, and blame output

Pros of delta

Specialized for git diff output with syntax highlighting and side-by-side view
Supports various output formats and themes
Integrates well with git and can be used as a pager

Cons of delta

Limited to diff viewing, not a general-purpose file listing tool
May require additional configuration for optimal use
Doesn't provide file metadata or tree-like structure views

Code comparison

delta:

git diff | delta

eza:

eza -la --git

exa:

exa -la --git

Key differences

Purpose: delta focuses on enhancing diff output, while eza and exa are modern alternatives to the ls command
Functionality: eza and exa provide rich file listing features, including icons and git status, whereas delta specializes in diff visualization
Use case: delta is primarily used in git workflows, while eza and exa are general-purpose file exploration tools

Similarities

All three projects aim to improve command-line experience
They support colorized output and customization options
Each tool can integrate with git to some extent

Conclusion

While delta excels at diff visualization, eza and exa offer more comprehensive file listing capabilities. The choice between them depends on the specific use case: delta for diff-focused workflows, and eza or exa for enhanced file exploration and listing.