Can you undo a git clean?

No, git clean is irreversible. Deleted files are not sent to the trash and are not recorded by Git (because they were untracked). That's why you should always use -n (dry run) before -f.

What is dry run (-n)?

The -n flag (or --dry-run) simulates running git clean without actually deleting anything. It shows the list of files that would be removed. It's an essential safety step before running the actual deletion with -f.

How do I also remove ignored files?

Use the -x flag with git clean to also remove files listed in .gitignore (like node_modules, .env, etc.). With -X (uppercase), only ignored files are removed, not other untracked files.

What is the difference between git clean and git restore?

git restore undoes changes to files already tracked by Git (reverts to the last committed version). git clean removes untracked files (that have never been added to Git). They act on different files.

How do I clean a specific directory?

You can specify a path: git clean -f path/to/directory/. Only untracked files in that directory will be removed. Combine with -n to check first.

Git clean: remove untracked files

Temporary files, logs, builds cluttering your project? git clean tidies up your working directory by removing everything that isn't tracked by Git.

Practice git clean Git Glossary

gitquest — enquête

Warning

What is git clean?

git clean removes untracked files from your working directory. These are files Git doesn't know about: they were never added with git add.

It's useful for starting fresh: removing temporary files, debug logs, build artifacts.

Warning: git clean is irreversible. Deleted files cannot be recovered. Always use -n (dry run) before -f (force).

Git clean options

git clean -n

Dry run: shows what would be removed

git clean -f

Force: removes untracked files

git clean -fd

Removes untracked files AND directories

git clean -fx

Also removes ignored files (.gitignore)

git clean -i

Interactive mode: choose file by file

Git clean in practice

Always check with -n before deleting with -f.

Dry run then clean

gitquest — clean

# Always check before deleting (dry run)

$git clean -n

Would remove temp.log

Would remove debug.txt

Would remove build/output.js

# OK, we can delete. -f to force

$git clean -f

Removing temp.log

Removing debug.txt

Removing build/output.js

With directories and ignored files

gitquest — clean -fdx

# Also remove untracked directories (-d)

$git clean -nd

Would remove temp.log

Would remove tmp/

Would remove dist/

$git clean -fd

Removing temp.log

Removing tmp/

Removing dist/

# -x to also remove ignored files (.gitignore)

$git clean -fdx

Everything cleaned up, including ignored files

When to use git clean?

Clean up after a build

Remove build artifacts (dist/, build/, .cache/) to start fresh before a new build.

Remove test files

Temporary files created during debugging (logs, exports, screenshots) that are not meant to be committed.

Start from scratch

Combined with git checkout ., you can return to a state identical to the last commit, with no extra files.

Safety rules with git clean

Always -n before -f

Run git clean -n to see what will be deleted. Then git clean -f only if the list is correct.

Be careful with -x

The -x flag also removes files ignored by .gitignore. This includes .env, node_modules, etc. Use it with caution.

Prefer interactive mode

git clean -i lets you choose file by file what to delete. Slower but safer.

Check your .gitignore

Make sure your .gitignore is up to date. Files that are neither ignored nor tracked will be removed by git clean.

Part of the Undo Changes in Git guide

Related commands

git status

View untracked files

git stash

Save rather than delete

git diff

See what changed

GitQuest is created by Anaïs (nouvelle fenêtre), web developer and head of education, specializing in tech training and digital accessibility.

Questions about git clean

Learn to clean your repo safely

GitQuest offers scenarios where you need to use git clean in a safe environment.

Start practicing now