Introduction

Printing a directory tree means turning a nested filesystem into a readable hierarchical view. The right solution depends on whether you want a quick shell command, a cross-platform script, or output you can filter and customize for another tool.

The Fastest Option on Unix-Like Systems

On Linux and macOS, the usual command is tree.

tree

Useful variations include:

tree -L 2
tree -a
tree -I '__pycache__|node_modules'

These options let you limit depth, include hidden files, or exclude noisy directories. If tree is not installed, it is usually available through the system package manager.

Windows Has a Built-In tree Command

On Windows, tree is available from cmd.

tree C:\Projects\MyApp /F /A

/F includes files and /A uses ASCII characters, which is often better for pasting into terminals, logs, or markdown files.

find Is a Useful Fallback

If tree is not available, find can provide a simple hierarchical listing, though it is less visually friendly.

find .

With some filtering:

find . -maxdepth 2 -type f

This does not draw branch characters, but it is available almost everywhere on Unix-like systems and is often enough for scripts or quick debugging.

A Portable Python Script

If you need a directory tree in a portable way, Python is a good fit. pathlib makes the recursion straightforward.

1from pathlib import Path
2
3
4def print_tree(root: Path, prefix: str = ""):
5    entries = sorted(root.iterdir(), key=lambda p: (p.is_file(), p.name.lower()))
6    for index, entry in enumerate(entries):
7        connector = "└── " if index == len(entries) - 1 else "├── "
8        print(prefix + connector + entry.name)
9        if entry.is_dir():
10            extension = "    " if index == len(entries) - 1 else "│   "
11            print_tree(entry, prefix + extension)
12
13
14print(Path("."))
15print_tree(Path("."))

This is a good approach when you need to customize sorting, skip certain directories, or emit the tree into a report file.

Add Filtering Early

Real projects usually contain generated directories, caches, and dependency folders that overwhelm the tree. Filtering makes the output much more useful.

1from pathlib import Path
2
3SKIP = {".git", "node_modules", "__pycache__"}
4
5
6def print_tree(root: Path, prefix: str = ""):
7    entries = [p for p in sorted(root.iterdir(), key=lambda p: p.name.lower()) if p.name not in SKIP]
8    for index, entry in enumerate(entries):
9        connector = "└── " if index == len(entries) - 1 else "├── "
10        print(prefix + connector + entry.name)
11        if entry.is_dir():
12            extension = "    " if index == len(entries) - 1 else "│   "
13            print_tree(entry, prefix + extension)

That small filter often matters more than the branch-drawing logic itself.

Decide Whether You Need Files, Directories, or Both

Some tasks need a full tree including files. Others only need folder structure. The command or script should reflect that.

• for structure review, directories only may be enough
• for deployment or packaging checks, include files
• for documentation, cap the depth so the output stays readable

A useful tree is not necessarily the most complete tree. It is the one that answers the question you actually have.

Common Pitfalls

• Printing the entire project root without excluding generated folders, resulting in unreadable output.
• Using Unicode branch characters in environments that need plain ASCII.
• Forgetting depth limits when the repository is large.
• Choosing a custom script when a built-in tree command already solves the problem.
• Printing files and directories together without considering what the reader actually needs.

Summary

• Use tree when you want the quickest human-readable directory hierarchy.
• Use Windows tree /F /A or Unix tree depending on the platform.
• Use find as a simple fallback when tree is unavailable.
• Use a Python script when you need portable, customizable output.
• Filter aggressively so the printed tree stays useful instead of noisy.