tree - Cross-Platform tree cli written in Rust

tree is an open-source tree command-line application that recursively displays the directory structure of a given path in a tree-like format, inspired by the Unix tree command. It is implemented in Rust and aims to provide a fast and efficient alternative with additional features, especially useful on platforms with no or limited tree cli features. Available for most platforms.

Website: https://peteretelej.github.io/tree/

Features

• Display directory structure in a tree-like format
• Control the depth of recursion (-L or --level)
• Show full path (-f or --full-path)
• No indentation (-i or --no-indent)
• Display hidden files (-a or --all)
• Include specific files matching patterns (-P or --pattern)
• Display the size of each file (-s or --size)
• Display the total size of each directory (-H or --human-readable)
• Colorize output (-C or --color)
• Turn Colorization off (-n or --no-color)
• Use ASCII characters for tree display (-A or --ascii)
• List directories only (-d or --directories)
• Exclude specific files matching patterns (-I or --exclude)
• Prune directories with no matching files when -P or -I is used (--prune)
• Apply -P pattern to directory names (--matchdirs)
• Send output to filename with -o flag
• Do not descend directories that contain more than # entries with --filelimit flag
• List directories first before files with dirsfirst flag
• Sort output by last modification time (-t)
• Reverse sort order (-r)
• Print last modification date (-D)
• Append file type indicators (/, *, etc.) (-F)
• Omit summary report (--noreport)
• Print permissions (-p)
• Read directory listing from a file or stdin (--fromfile)

Please feel to open PR requests in case interested in implementing some of the pending features.

Installation

Download Binaries

You can easily download binaries for different platforms from the Releases Page (Windows, MacOS, Linux).

• Download and unzip for your plaform
• If placing in $PATH, you can rename it to avoid confusing with any other tree binaries

Build from Source

If you have Rust and Cargo installed, you can build the project by running:

git clone https://github.com/peteretelej/tree.git
cd tree
cargo build --release

./target/release/tree -L 2 .  # or use --level=2
# copy tree binary to a PATH directory

The resulting binary will be located at ./target/release/tree.

Windows 7 Support

For Windows 7 compatibility, use Rust 1.75 with the provided lockfile:

rustup install 1.75.0
cp Cargo-win7.lock Cargo.lock
rustup run 1.75.0 cargo build --release

# restore default rust toolchain version
rustup default stable

Usage

./tree [FLAGS] [OPTIONS] [PATH]

# Get help and see all available options
./tree --help

For example:

# Using short flags
./tree -L 2 .
./tree -a -f -s .
./tree -P "*.txt" -I "*.log" .

# Using long flags
./tree --level=2 .
./tree --all --full-path --size .
./tree --pattern="*.txt" --exclude="*.log" .

# Hide directories that have no matching files
./tree --pattern="*.txt" --exclude="*.log" --prune .

Using as Rust Crate

use rust_tree::tree::{list_directory, options::TreeOptions};

fn main() {
    let path = ".";
    let options = TreeOptions {
        full_path: true,
        no_indent: true,
        ..Default::default()
    };
    list_directory(path, &options).unwrap();
}

The library now also provides list_directory_as_string function that returns the tree output as a String instead of writing to stdout, useful when you need to capture the output for further processing.

Using the bytes_to_human_readable function to print human readable file sizes

use rust_tree::utils::bytes_to_human_readable;
use std::fs;

fn main() {
    let metadata = fs::metadata("my_file.txt").unwrap();
    let size = metadata.len();
    let size_str = bytes_to_human_readable(size);
    println!("File size: {}", size_str);
}

Development

Contributing

Contributions are welcome! If you have any suggestions, feature requests, or bug reports, please feel free to open an issue or submit a pull request on the GitHub repository.

Code Formatting

This project uses standard Rust formatting. Before submitting a PR:

# Format your code
cargo fmt

# Verify formatting
cargo fmt --check
# run the pre-push script to ensure code quality
./scripts/pre-push

Consider copying the pre-push script to your git hooks directory:

cp scripts/pre-push .git/hooks/pre-push

VS Code Settings

For VS Code users, add this to your settings.json:

{
  "[rust]": {
    "editor.formatOnSave": true,
    "editor.defaultFormatter": "rust-lang.rust-analyzer"
  }
}

Releasing a new version

tree cli Release Process

Update version in Cargo.toml and push a tag:

# Update version in Cargo.toml to 1.2.3
git add Cargo.toml
git commit -m "version 1.2.3"
git tag -a v1.2.3 -m "tree v1.2.3"
git push origin v1.2.3

GitHub Actions will automatically build binaries and publish to GitHub releases and crates.io.

Docs

• Privacy Policy
• Terms of Use
• Support

License

MIT