How to remove a directory in Linux

Removing directories in Linux keeps file systems tidy and prevents obsolete data from consuming disk space. Regular cleanup of temporary folders, build artefacts, and outdated project trees reduces clutter and simplifies navigation in terminals and scripts.

Directory removal on Linux primarily relies on the rmdir and rm commands. rmdir removes only empty directories, while rm with recursive options can delete directories along with their files and subdirectories. Both tools operate directly on file system entries without moving data to a trash or recycle area.

Option choices significantly influence safety, because recursive and forced removal options bypass confirmation prompts and cannot be undone from the command line. Commands such as rm -r and rm -rf can remove large directory trees or critical system paths if pointed at the wrong location. Careful path checks, conservative options, and a quick ls before deletion reduce the risk of unintended data loss.

Steps to remove a directory in Linux:

Open a terminal on a Linux system.
```
$ echo $SHELL
/bin/bash
```
Change to the parent directory that contains the directory to be removed.
```
$ cd /path/to/parent-directory
$ pwd
/path/to/parent-directory
```
Using an absolute path reduces the chance of deleting a similarly named directory elsewhere in the file system.
List the parent directory to confirm the target directory name and whether it appears empty.
```
$ ls -l
drwxr-xr-x  2 user user 4096 Jun 10 10:01 empty-dir
drwxr-xr-x  3 user user 4096 Jun 10 10:02 project-dir
```
ls does not display internal entries like . and .., but any listed files or subdirectories show that a directory is not empty.
Use the rmdir command to remove an empty directory.
```
$ rmdir empty-dir/
```
rmdir completes silently on success and prints an error only if removal fails.
Check the error message from rmdir if the directory is not empty.
```
$ rmdir project-dir/
rmdir: failed to remove 'project-dir/': Directory not empty
```
rmdir removes only empty directories and never follows directory trees, which makes it conservative but limited.

Review available options for rmdir when automating directory cleanup.

$ rmdir --help
Usage: rmdir [OPTION]... DIRECTORY...
Remove the DIRECTORY(ies), if they are empty.

      --ignore-fail-on-non-empty
                  ignore each failure that is solely because a directory
                    is non-empty
  -p, --parents   remove DIRECTORY and its ancestors; e.g., 'rmdir -p a/b/c' is
                    similar to 'rmdir a/b/c a/b a'
  -v, --verbose   output a diagnostic for every directory processed
      --help      display this help and exit
      --version   output version information and exit

GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Full documentation <https://www.gnu.org/software/coreutils/rmdir>
or available locally via: info '(coreutils) rmdir invocation'

The -p option removes parent directories in a path when each becomes empty, which is useful for cleaning nested directory structures.

Attempt to remove a non-empty directory with rm to see the default behavior.
```
$ rm project-dir/
rm: cannot remove 'project-dir/': Is a directory
```
By default, rm expects file operands and reports an error when given a directory without recursive options.
Remove a non-empty directory recursively using rm with the -r option.
```
$ rm -r project-dir/
```
The -r or -R option instructs rm to traverse and delete all files and subdirectories under the target directory.

Inspect rm help output to understand confirmation and safety options before using recursive deletion widely.

$ rm --help
Usage: rm [OPTION]... [FILE]...
Remove (unlink) the FILE(s).

  -f, --force           ignore nonexistent files and arguments, never prompt
  -i                    prompt before every removal
  -I                    prompt once before removing more than three files, or
                          when removing recursively; less intrusive than -i,
                          while still giving protection against most mistakes
      --interactive[=WHEN]  prompt according to WHEN: never, once (-I), or
                          always (-i); without WHEN, prompt always
      --one-file-system  when removing a hierarchy recursively, skip any
                          directory that is on a file system different from
                          that of the corresponding command line argument
      --no-preserve-root  do not treat '/' specially
      --preserve-root[=all]  do not remove '/' (default);
                              with 'all', reject any command line argument
                              on a separate device from its parent
  -r, -R, --recursive   remove directories and their contents recursively
  -d, --dir             remove empty directories
  -v, --verbose         explain what is being done
      --help     display this help and exit
      --version  output version information and exit

By default, rm does not remove directories.  Use the --recursive (-r or -R)
option to remove each listed directory, too, along with all of its contents.

To remove a file whose name starts with a '-', for example '-foo',
use one of these commands:
  rm -- -foo

  rm ./-foo

Note that if you use rm to remove a file, it might be possible to recover
some of its contents, given sufficient expertise and/or time.  For greater
assurance that the contents are truly unrecoverable, consider using shred.

GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Full documentation <https://www.gnu.org/software/coreutils/rm>
or available locally via: info '(coreutils) rm invocation'

Interactive flags such as -i and -I add protection by requesting confirmation before destructive operations.

Apply forced recursive removal when a directory is write-protected and ownership is correct.
```
$ rm -r protected-dir/
rm: remove write-protected regular file 'protected-dir/locked.txt'? n
rm: cannot remove 'protected-dir/locked.txt': Permission denied
$ rm -rf protected-dir/
```
The combination rm -rf removes files without prompting, so an incorrect path (for example, / or /home) can cause immediate and irreversible data loss.
Use sudo with rm when the directory requires elevated privileges for removal.
```
$ rm -r /var/log/custom-app/
rm: cannot remove '/var/log/custom-app/app.log': Permission denied
$ sudo rm -r /var/log/custom-app/
[sudo] password for user:
$
```
Restrict sudo rm -r to paths that are fully understood and avoid targeting critical system locations such as /etc or /usr.

Related: How to configure passwordless sudo on Linux
Verify removal by listing the parent directory and checking that the target directory no longer appears.
```
$ ls -l
total 0
```
A missing directory name from the listing confirms successful deletion.

Author: Mohd Shakir Zakaria
Mohd Shakir Zakaria is a cloud architect with deep roots in software development and open-source advocacy. Certified in AWS, Red Hat, VMware, ITIL, and Linux, he specializes in designing and managing robust cloud and on-premises infrastructures.

Discuss the article:

Comment anonymously. Login not required.