Git Clean: Safely Remove Untracked Files & Folders (Complete Guide for 2026)

Published February 16, 2026 · 10 min read

git clean is the command you use when your working tree is full of untracked junk: build artifacts, temporary files, generated folders, and leftovers from switching branches.

It’s also a command that can delete things permanently if you run it carelessly.

1. Copy/paste recipes (the 90% cases)

Preview what would be deleted (recommended)

# Dry run: prints what would be removed
git clean -n

# Dry run, including untracked directories
git clean -nd

Delete untracked files (not directories)

# Remove untracked files in the current repo
git clean -f

Delete untracked files and directories

# Common “clean everything untracked” command
git clean -fd

Delete only ignored files (keep other untracked files)

# Remove ignored files only (build output, node_modules if ignored)
git clean -fX

# Include ignored directories too
git clean -fdX

Delete untracked + ignored files (dangerous)

# Most destructive form: removes *everything* not tracked by Git
# Always run the dry-run first: git clean -ndx
git clean -fdx

Interactive mode (choose what to delete)

git clean -di

2. What git clean deletes (and what it won’t)

git clean operates on files that are not tracked by Git. Think “junk that Git doesn’t know about”.

This is the key mental model:

• git clean is for untracked (and optionally ignored) files.
• git restore is for discarding edits to tracked files.
• git reset/git revert are for commit history.

3. The safe workflow (status → dry-run → delete)

When in doubt, do this exact sequence:

# 1) See what’s going on
git status

# 2) Preview deletion
git clean -nd

# 3) Delete untracked (only after confirming)
git clean -fd

4. Flags you actually need

You don’t need to memorize every option. These are the ones you’ll use constantly:

5. Cleaning ignored files (node_modules, dist, target)

Most people reach for git clean because their repo contains huge ignored folders (like node_modules/) or build output (dist/, build/, target/).

Remove only ignored files and folders

# Dry run first
git clean -ndX

# Then remove ignored directories too
git clean -fdX

This is usually safer than -x because it won’t delete “random untracked stuff” you actually care about.

Remove ignored + untracked (full cleanup)

# Dry run first
git clean -ndx

# Full cleanup
git clean -fdx

6. Interactive cleaning (git clean -di)

If you want an extra safety layer, use interactive mode. It walks you through what can be deleted and lets you choose:

git clean -di

Interactive mode is great when you have a mix of generated files and “real” local files, and you’re not confident your ignore patterns are perfect.

7. Excluding files and folders (-e)

Exclusions let you keep specific paths even when they’re untracked. This is especially useful for local secrets, environment files, or per-developer configs.

Example: keep a local .env file

# Preview deletion, but keep .env
git clean -nd -e .env

# Delete untracked files/dirs, but keep .env
git clean -fd -e .env

Example: clean everything except node_modules

# Maybe node_modules isn't ignored in this repo; keep it explicitly
git clean -fd -e node_modules/

-e uses Git’s ignore pattern rules (similar to .gitignore), so you can exclude folders, globs, and specific filenames.

8. Common real-world use cases

“My repo is messy after switching branches”

# Preview
git clean -nd

# Clean untracked files + directories
git clean -fd

“I want a clean slate before running a build”

# Remove ignored build output only (safer)
git clean -fdX

“CI should start from a pristine working tree”

# WARNING: destructive. Typical CI pattern.
git reset --hard
git clean -fdx

If you’re trying to discard edits to tracked files (not untracked junk), use git restore instead.

9. Cleaning submodules

Submodules have their own working trees. If the root repo is clean but a submodule is full of untracked files, clean them recursively:

# Preview in each submodule
git submodule foreach --recursive 'git clean -nd'

# Clean untracked files/dirs in each submodule
git submodule foreach --recursive 'git clean -fd'

For a deeper explanation of submodules (and how to avoid common pitfalls), see Git Submodules: Complete Guide.

10. Troubleshooting

“git clean does nothing”

Most often, one of these is true:

• You forgot -f (force). Without it, Git refuses to delete.
• The things you want to remove are ignored, so you need -X or -x.
• You need -d because the “junk” is a directory.

“It won’t remove directories”

Add -d:

git clean -fd

“I deleted the wrong file”

If the file was truly untracked, Git can’t recover it because it was never in history. For future safety:

• Always do a dry run: git clean -n.
• Use interactive mode: git clean -di.
• Stash untracked files instead of deleting: git stash -u.

“I actually wanted to discard edits to a tracked file”

That’s not what git clean is for. Use git restore path/to/file (see Git Restore).

FAQ

Why does git clean require -f?

Because deleting files is irreversible for untracked paths. Git forces you to add -f to avoid accidental deletion from a mistyped command.

How do I clean only one folder?

Pass a pathspec after -- to limit what’s cleaned:

# Only clean inside dist/
git clean -fd -- dist/

Should I use git clean or rm -rf?

rm -rf will delete anything you point it at. git clean is safer in a repo because it targets only untracked/ignored files and supports dry runs and interactive mode.

If you want a broader “what should I run?” decision guide for undo operations (including reset vs revert vs restore and recovery with reflog), see: Git Undo: Reset, Revert & Restore.