
Import your project
Choose a local folder, GitHub/GitLab repository, ZIP, or existing tree text. You can also start with the sample.
Import a folder, GitHub/GitLab repository, or ZIP. Hide generated files, explain key paths with annotations, and copy the result into your README.
No sign-up or install. Local folders are processed in your browser.
Live directory tree workspace
Start with the sample or import your own project. Hide an unneeded folder, add a note to an entry point, and preview the result before copying or downloading it.
Loading the live workspace
The directory tree editor runs in your browser so you can try the workflow without creating an account.
Why dir-tree
A complete file listing can bury the entry points your readers need. Leave out dependencies, build output, and caches. Explain the folders that matter without changing the files on disk.

Import a folder, repository, ZIP, or existing tree instead of recreating the hierarchy by hand.
Folder import · Repo URL · ZIP · Remote ZIP · Tree output
Before
README draft - copied terminal output - old folder list - manual cleanup notes
After
my-app/ ├── app/ // routes ├── components/ // reusable UI └── package.json // dependencies
Use depth limits, ignore rules, and hidden nodes to leave out generated files and focus on the structure you want to explain.
Depth · .gitignore · Exclude rules · Hide nodes
Before
$ tree -L 3 . ├── node_modules/ ├── .next/ ├── dist/ ├── src/ └── package.json
After
my-app/ ├── src/ // app code └── package.json // dependencies
Add notes to files and folders, then choose compact inline text or aligned columns. Use manual notes or review optional AI suggestions.
Manual notes · Optional AI · Annotation layouts
Before
├── auth.ts // auth? ├── api.ts // client └── format.ts // helper
After
├── auth.ts // sign-in flow ├── api.ts // API client └── format.ts // text formatting
Copy the output or download Markdown, TXT, or JSON for your README, documentation, or pull request.
Tree style · Markdown · TXT · JSON
Before
Paste raw output fix spacing wrap code block repeat next time
After
Ready to publish Copy to clipboard Download Markdown Download TXT Export JSON
Workflow
Bring your project into one workspace, choose what readers should see, and prepare an annotated tree for your documentation.

Choose a local folder, GitHub/GitLab repository, ZIP, or existing tree text. You can also start with the sample.

Limit the depth, apply ignore rules, and hide irrelevant nodes. The original files stay unchanged.

Explain key paths, choose the annotation layout, and copy or download your finished tree.

Use cases
Give readers the right level of detail, whether they are opening a repository for the first time or reviewing a structural change.

Open-source maintainers and template authors
Show entry points, configuration, and key folders without burying them in generated files.
starter-kit/ ├── app/ // routes and layouts ├── components/ // reusable UI ├── lib/ // shared utilities └── README.md // setup guide

Technical writers and developer advocates
Explain the role of routes, models, components, and shared utilities alongside their paths.
api-service/ |-- routes/ // HTTP endpoints | |-- auth.ts // JWT & sessions | `-- users.ts // user CRUD |-- models/ // DB schemas `-- middleware/ // request pipeline

Engineers reviewing refactors
Give reviewers a compact map of the structure affected by a refactor.
src/ ├── auth/ // sign-in flow ├── hooks/ // shared hooks ├── utils/ // shared helpers └── README.md // structure notes

CS instructors and course creators
Help new contributors and students find the files they should explore first.
lesson-01/ |-- starter/ // student begins here | `-- index.js // entry point `-- solution/ // instructor reference
Guides & examples
Follow focused walkthroughs for turning real projects into clean, annotated README documentation.
Comparison
Terminal tree works well for snapshots and scripted workflows. dir-tree brings folder, repository, and ZIP imports together with visual editing, annotation layouts, optional AI suggestions, and document exports.
| Capability | Terminal `tree` | tree.nathanfriend.com | dir-tree |
|---|---|---|---|
| Reads real local directories | Yes | No | Yes |
| Browser-based, no install | No | Yes | Yes |
| Local and remote ZIP support | No | No | Yes |
| GitHub/GitLab repository URLs import | No | No | Yes |
| Import existing ASCII / JSON / XML trees | Output only | Limited | Yes |
| Visual editing and hide nodes | No | Edit only | Yes |
| Tree style customization | Manual flags and cleanup | Basic visual options | Connector style, indentation, root path display, metadata, and annotation templates |
| Annotation column alignment | No | No | Yes |
| Manual and optional AI annotations | No | No | Yes |
| Documentation-ready Markdown / TXT / JSON export | Raw output | Generated ASCII | Styled and annotated |
Privacy boundary
Work with local folders and ZIPs in your browser. Use remote imports and optional AI when you need them.
Read, edit, and export your local project structure in the browser.
Repository and remote ZIP imports connect to the source you choose.
Send selected context when you request suggestions. Review them before applying.

Optional AI data flow
AI uses the context you provide without automatically reading project source files.
FAQ
Import a local folder, GitHub or GitLab repository, ZIP, or existing tree output. Hide generated folders, add annotations, choose Unicode or plain ASCII connectors, then copy the result or export Markdown. Your original files are not changed.
Select or drag a local folder into dir-tree. The browser reads file and folder names and hierarchy locally so you can filter, edit, annotate, and export the structure without uploading file contents.
dir-tree imports local folders, GitHub/GitLab repository URLs, local ZIP files, remote ZIP URLs, `tree` command output, JSON, XML, HTML, and Markdown lists. Each source becomes one editable directory tree.
Project file contents are not uploaded to generate a tree. Local folders, ZIP files, ignore rules, and imported tree text are processed in your browser. Remote imports contact GitHub, GitLab, or the ZIP host. Optional AI annotations send selected paths, node types, existing annotations, settings, and your prompt, not project source files.
The terminal tree command is useful for snapshots, filtering, and scripted workflows. dir-tree adds a browser workspace for importing different sources, editing the displayed structure, writing and aligning annotations, and exporting a version prepared for documentation.
Yes. Add notes to files or folders, then choose inline text or aligned columns. Aligned layouts support Adaptive, Global column, and Per-folder columns. Export preserves the spacing; use a monospaced code block in your README. Mixed-language text and emoji may still appear uneven when the destination font uses different character widths.
Unicode trees use connectors such as `├──` and `└──` for clearer visual structure. Plain ASCII uses basic-character connectors such as `|--` and `+--`, making it suitable for older terminals and restricted text environments. Both styles support annotations, copying, and export.
Yes. Optional AI suggestions use selected paths, existing annotations, generation settings, and your prompt rather than reading your project source files. Review the suggestions before applying them: a file name alone may not explain what the code does. Requests support up to 500 nodes, including files and folders. The current allowance is 10 free requests per IP per day, resetting at 00:00 UTC.
Yes. You can limit visible depth, use `.gitignore`, apply exclude patterns, hide generated folders, collapse folders, and export a focused tree for documentation or review.
Ready to generate your first directory tree?
Open the free browser workspace. No sign-up or install required.
Try dir-tree in your browser