Learn Linux tree Command with Easy Examples

The tree command in linux with examples is the fastest way to visualize any directory structure at a glance. ls -R is fine as long as there are only 400 files in the directory. At that point, you have scrolled through a mountain of text looking for the subdirectory where all your work was done. On the other hand, when you run tree, you will wonder why you had not done things like this from the very beginning.

The first time someone gave me a new server and told me to “poke around” to get an idea of the project layout, I ran ls -R. The results were a list of 600 lines of text with absolutely no visual organization. A senior engineer walked by while I was working, saw my screen, and said “you need to use tree.” He then continued on his way. After I installed tree, which took about 30 seconds, I have been using it every day since.

This document is for everyone who works with Linux directories on a regular basis, whether they are just starting out or have been doing this for years and simply never taken the time to sit down and learn what each flag does. By the end of this article, you should be able to look at a project’s directory layout and determine its overall structure. In addition to reading a project’s directory layout, you will also be able to filter what you want to see within that layout. This means you can choose to show only certain parts of a directory structure. Lastly, you will learn how to save copies of directory layouts to reference later if needed.

Examples

The tree command reads a directory and prints its entire contents files, subdirectories, and nested subdirectories in a branching visual layout that looks like an actual tree. Instead of a flat list of filenames, you get indented branches with connecting lines showing you exactly how everything relates to everything else.

Under the hood, it's doing what ls -R does recursive directory listing but it formats the output so you can actually read it. The final line of every tree output also gives you a quick count of directories and files found, which is useful when you're auditing a directory and want a fast summary without counting manually.

Think of it like this: ls shows you what's in the room you're standing in; tree shows you the whole floor plan of the building. If you've ever used the find command just to understand what's inside a directory, tree will do that job with far less typing and far more readable output.

The tree command is not installed by default on most Linux distributions. It's in the standard repositories for all major distros, so installation is a single command.

On Rocky Linux 9 and RHEL 9, use dnf not yum. While yum is aliased to dnf on RHEL 8+, using dnf directly is the current standard and avoids any deprecation warnings on newer releases.

The tree part is the command itself. [options] are the flags you add to control what gets shown and how. [directory] is the path you want to inspect if you leave it blank, tree uses the current working directory. That's the most common usage: just type tree where you are.

The simplest use: just type tree in any directory and it will recursively display everything from that point down. This is where most people start, and it's often all you need.

When you want to understand the folder structure of a project without the noise of individual files getting in the way, -d gives you the skeleton only.

By default tree skips hidden files anything starting with a dot. When you're auditing a project for configuration files, SSH keys, or .env files, you need -a to see the full picture.

On any directory with real depth, running tree with no depth limit is like opening every drawer in a filing cabinet at once. Use -L to control how deep it goes. Level 2 is a good starting point for most projects.

The -f flag forces tree to print the full path prefix for every entry relative to the directory argument provided. By passing the "$(pwd)" command substitution as the target directory, you trick the terminal into feeding tree an absolute starting point, yielding copy-paste-ready absolute file paths.

Use the -h flag to display file and directory sizes in a human-readable format (like K, M, or G) instead of raw bytes. This makes it instantly obvious which files are consuming the most storage space.

Combine -p, -u, and -g together to get a long-listing-style view of every file in the tree. This is useful during permission audits you get the full ownership picture across the entire directory structure in one output, which would take many individual ls -l commands to replicate.

The -P flag accepts a wildcard pattern and limits output to only matching files. Use this when you know the type of file you're looking for and don't want to scroll through everything else. The --prune option removes empty directories from the output so you only see directories that actually contain matches.

When debugging, you often want to know which files changed most recently. The -t flag sorts the tree by modification time rather than alphabetically. Pair it with -D to also print the modification timestamp alongside each file.

The -o flag redirects tree's output directly to a text file. This is genuinely useful for documentation: generate a snapshot of a project structure, commit it to the repo, and anyone joining the project gets an instant orientation. It's also useful in CI/CD pipelines where you want to record what was deployed and when.

You can verify the contents of the generated documentation file using the cat command:

Before going live, run tree with permissions and ownership flags on your deployment directory. This gives you a single, scannable output showing the full structure plus ownership useful for catching files that deployed under the wrong user or directories that are missing entirely.

This is the one most people learn the hard way. Running tree / with no depth limit tells tree to recurse the entire filesystem every directory, every subdirectory, everything under /proc, /sys, and virtual filesystems. On a production server this can take minutes and produce millions of lines of output.

There's a certain kind of task that comes up constantly in this work: you inherit a server, a project, or a configuration directory you've never seen before and you need to understand it fast. Before you can fix anything, configure anything, or hand it off to someone else, you need a mental model of where everything is. ls shows you one level at a time. find gives you a flat list with no sense of hierarchy. tree shows you the whole shape at once, and that shape is often enough to tell you immediately what's wrong a missing directory, files where they shouldn't be, a structure that doesn't match what was documented.

In production environments, tree becomes a documentation tool as much as a navigation tool. Running tree -L 3 -I "node_modules|.git" -o structure.txt before a deployment gives you a pre-deployment snapshot you can compare against post-deployment. Running tree -pug on a web root gives you a permission audit in seconds that would take many minutes to replicate with repeated ls -l calls across subdirectories. These aren't clever tricks they're just efficient ways to do things you're already doing. The foundational Linux commands get you moving; tree is one of the tools that makes you faster at the work that actually matters. The official tree man page is also worth bookmarking for the less-common flags you'll reach for occasionally.

The bigger point is this: the commands that improve your workflow the most are rarely the complex ones. Tree is a small utility that does one thing and does it cleanly. Once it's in your muscle memory, you'll find yourself reaching for it instinctively whenever you land in an unfamiliar directory and the few seconds it saves you, dozens of times a day, add up to real time back in your week.