rm deletes files. It is short, it is fast, and unlike deleting something through a desktop file manager, it does not put anything in a recycle bin first. Understanding exactly what it does before running it, especially with its more powerful flags, matters more than with almost any other command covered in this series.

Basic usage

rm file.txt
rm file1.txt file2.txt file3.txt

Running rm on a file removes it immediately. There is no confirmation, no trash folder, and no built-in undo. If you delete the wrong file, recovering it is not something the command itself supports at all.

Deleting directories: the -r flag

rm olddir
# rm: cannot remove 'olddir': Is a directory

rm -r olddir
# succeeds, deleting the directory and everything inside it

Plain rm refuses to touch directories at all, as a basic safety measure. The -r (recursive) flag overrides that refusal, deleting the target directory along with every file and subdirectory nested inside it.

Skipping confirmation and errors: the -f flag

rm -f file-that-might-not-exist.txt
# succeeds silently even if the file was never there

rm file-that-might-not-exist.txt
# rm: cannot remove 'file-that-might-not-exist.txt': No such file or directory

-f (force) does two things: it suppresses any confirmation prompt, and it silently ignores files that do not exist instead of raising an error. This is useful in scripts, where you want deletion to always succeed regardless of whether the target was actually present, but it removes a layer of protection against typos when used interactively.

Why rm -rf specifically gets so much caution

rm -rf /path/to/directory

Combining -r and -f means: delete this entire directory tree, recursively, immediately, with no prompt and no error even if something is missing. Every safety net that could have caught a mistake, a confirmation step, an error on a missing path, is deliberately disabled. This combination is genuinely useful and extremely common in scripts and cleanup routines, but it also means a small mistake, an extra space, a wrong variable, a wildcard that expanded further than intended, can delete far more than planned with zero warning.

# A classic and very real mistake: a stray space before the wildcard
rm -rf /home/colton/tempfiles /*
#                             ^ this leading slash-star, meant to be
#                               attached to the previous path, instead
#                               matches everything at the filesystem root

Modern versions of rm specifically refuse to run rm -rf / on the literal root directory as a hardcoded safety check, but this protection is narrow. It does not protect against rm -rf on any other broad, mistaken, or wildcard-expanded path, which is by far the more common real-world way people cause serious damage with this command.

Safer habits around rm

# Preview exactly what a wildcard or path will match, before deleting
ls olddir/*.log

# Then, once confirmed, delete it
rm olddir/*.log

# Use -i to force a per-file confirmation prompt
rm -i important-looking-file.txt
# rm: remove regular file 'important-looking-file.txt'? y

Many distributions alias rm to rm -i by default specifically to add this confirmation step back in for interactive use. Running ls with the exact same path or pattern you are about to pass to rm is a cheap, effective habit: if ls shows exactly what you expected, rm with the same pattern will only touch those same files.

Removing empty directories specifically: rmdir

rmdir empty_folder
# succeeds only if the directory is completely empty

rmdir folder_with_files
# rmdir: failed to remove 'folder_with_files': Directory not empty

rmdir is a separate, more conservative command that only removes directories that are already empty, refusing outright if anything is still inside. It is a useful safety-first alternative to rm -r when you specifically intend to remove an empty directory and want an error if it turns out not to be empty after all.

Recovering from an accidental rm

There is no built-in undo. Once rm completes successfully, the file’s directory entry is gone and the space it occupied is marked available for reuse. Data recovery tools like extundelete, photorec, or testdisk can sometimes recover recently deleted files from certain filesystems if you stop using the affected disk immediately, but success is not guaranteed and depends heavily on the filesystem type and how quickly you act. This is precisely why third-party trash utilities exist: trash-cli and similar tools intercept deletion and move files to a recoverable trash location instead of calling rm directly.

Frequently Asked Questions

What does the rm command do?

rm removes (deletes) files from the filesystem. Unlike deleting a file in a graphical desktop environment, rm does not move files to a trash or recycle bin by default. Once rm succeeds, the file is gone, and recovering it typically requires specialized data recovery tools with no guarantee of success.

What do the -r and -f flags do in rm -rf?

-r (recursive) allows rm to delete directories and everything inside them, since plain rm refuses to remove a directory on its own. -f (force) suppresses confirmation prompts and ignores nonexistent files instead of raising an error. Combined as rm -rf, this deletes an entire directory tree immediately with no confirmation step and no error even if some target does not exist, which is why it is treated with particular caution.

Why is rm -rf considered dangerous?

It combines two properties that remove every safety net at once: recursive deletion of entire directory trees, and no confirmation prompt before it happens. A single typo, an extra space before a wildcard, or running it in the wrong directory can delete far more than intended, and there is no undo. Historically, commands like rm -rf / (attempting to delete the entire filesystem) were a real risk on older systems; modern rm refuses this specific case by default as a safety measure, but rm -rf on any other broad or mistaken path still executes without hesitation.

Does rm ask for confirmation before deleting?

By default on many distributions, rm is aliased to rm -i for interactive use, which prompts for confirmation before removing each file. Without that alias, or when -f is used, rm does not ask at all. Using rm -i explicitly is a reasonable habit when deleting something you have not carefully double-checked with ls first.

How can I preview what rm would delete before actually deleting it?

Run the equivalent ls command with the same path or wildcard pattern first, such as ls olddir/* before rm -rf olddir/*, to see exactly what will be affected. Some people also use find with -print instead of -delete as a dry run, since find’s pattern matching can be more precise than a shell wildcard and it is easy to review the list of matches before switching to actual deletion.

Is there a safer alternative to rm for everyday use?

Several third-party tools, such as trash-cli or trash-put, move files to a trash directory instead of deleting them immediately, mimicking a desktop recycle bin from the command line and allowing recovery if a mistake is discovered shortly afterward. These are not part of core coreutils and need to be installed separately, but many people who have been burned by rm once adopt one of these tools or a personal shell alias afterward.