How to Rename a Directory in Linux: Command Guide & Examples

Rename Directory Linux Process: Explained

Renaming a directory on Linux keeps your filesystem clean and your workflow processes organized. For instance, clearing folder names can reduce mistakes when you move files or deploy code.

On the other hand, a small change to the directory name can avoid conflicts with the same exact name in the current directory or another location. This makes the “mv command” necessary in many cases.

So, let’s learn more about when renaming directories really helps.

Using mv command to rename directory on Linux.

Rename a File / Move a File | Common Scenarios

You rename a directory during normal system work more often than you expect.

Here are common cases:

Fixing Typos: You correct naming mistakes early so scripts, links, and tools do not break when they try to read the wrong path or file.
Aligning Versions: You separate stable and test builds by renaming operations instead of duplicating data or wasting storage on another copy.
Reorganization: You move files and folders into a new location to match updated project structure or access rules.
Directory Cleanup: You group related files and directories under clear names so navigation stays fast and mistakes are reduced.
Backup Preparation: You standardize folder names before copying data to another system to avoid missing content during transfer.
Name Conflicts: You apply a new name to one directory so the filesystem does not confuse source and destination targets.
Automation Readiness: You align naming rules so scheduled jobs and deployment tools work without manual fixes.
Log Organization: You rename folders to reflect time ranges or clients, so audits and troubleshooting take less time.

Rename Files and Directories – Methods Preview

You have three main tools to rename a directory in Linux. Each fits a different case depending on scale, path, and how many files and directories you need to handle.

Learn: How to Find Files on Linux with Find and Locate

1. mv command (fast and direct)

As mentioned, the mv command is used when you just need to change a file or directory name. It is the system default command and, of course, the most frequently used one. However, it affects only a single file and works by providing the current and the new name/directory.

Then the system changes it.

So, to rename a file, use mv old_name new_name. Here is how the command must look without the brackets: “mv banana apple“. We just changed a file’s name from “banana” to “apple” with a single command. There should be a space between [old] and [new] name.

It works exactly the same when used to change directory names. However, if a folder is not in the current directory, the mv command requires the full path to the folder. Also, the command will fully overwrite the existing file, unless you deploy some safety options:

<-i> is used to show a confirmation prompt before overwriting. It will ask you whether or not you want to proceed.
<-u> is to move files only when the source file is created more recently than the destination file, preventing potential issues.
-v to show output for each item. The -v option enables verbose mode, displaying the files being moved successfully in the terminal.

Note: The mv command can be used to move multiple files at once using wildcards.

Here’s an example of the mv command:

# Rename a directory in the current directory
mv old_folder new_folder

# Rename a folder using full path
mv /home/user/project /home/user/project_v2

# Rename a folder with spaces
mv "My Folder" "My Folder Backup"

# Rename with prompt before overwrite
mv -i reports reports_old

# Rename multiple files using wildcard
mv *.txt archive/

# Verbose output
mv -v test_folder final_folder

See Also: How to Unzip Files in Linux

2. find command (search + rename)

Use find when you do not know the exact path or when folders, files, and directories are spread across many locations. It searches the filesystem by name, type, depth, or size. Then it passes each match to another command like mv or rename, for processing.

This method fits large servers, old backup trees, and messy project layouts. It helps avoid changing the same file in the wrong directory and ultimately reduces the risk of the wrong destination being replaced.

Here’s an example of the find command:

# Find and rename a directory by name
find /home/user -type d -name "old_folder" -exec mv {} {}_backup \;

# Find and rename all .txt files
find . -type f -name "*.txt" -exec mv {} {}.bak \;

# Find directories and move them to a new location
find /var/log -type d -name "2026*" -exec mv {} /backup/logs/ \;

# Prompt before overwriting
find . -type f -name "report.txt" -exec mv -i {} /archive/ \;

# Verbose rename
find . -type d -name "test*" -exec mv -v {} {}_final \;

3. rename command (multiple files)

The rename command is quite interesting. It works ideally when you want to rename multiple files with one single line of code. It can update the filename or directory when both are in the same location. It will not move the data to another location, though.

This makes the command just perfect for bulk cleaning, importing any critical content, or even altering the logs. You simply define a rule, and the command applies it to all items that obey your requirements.

Here’s an example of the rename command:

# Change file extension from .txt to .bak
rename 's/\.txt$/.bak/' *.txt

# Add prefix to all files
rename 's/^/backup_/' *

# Replace part of a name
rename 's/report_/client_/' report_*

# Rename folders by pattern
rename 's/v1/v2/' */

# Test without applying changes
rename -n 's/old/new/' *

⚠️Notes You Should Know:

Use -n to run a test without changing anything in the directory
Use -v to show output for each renamed item, without altering
Always think about permissions before running batch changes
Large batches affect filesystems instantly and are irreversible

See Also: How to Block an IP Address

Rename Directories with mv

As we have mentioned already, the Linux mv command is the absolute fastest way to rename files and directories through the Linux OS terminal. The mv command can also move a file or even entire folders into a new destination directory. Most administrators spam this command on a daily basis, especially for minor required updates after a deployment post.

Basic Syntax

This is the following command format:

mv old_directory new_directory

This immediately prompts the system to change the directory name.

To verify the result, list the folder:

ls

If the “mv” operation successfully moved the pinpointed folder, the folder will now appear under the new name or the new chosen destination. It’s really that simple.

⚠️Moving vs Renaming

It’s important to verify your action, because the operation may look successful, but the result could be wrong. If a target already exists, mv will change its behavior. Instead of renaming, the source folder could have been moved into the target directory.

Files appear removed from the original path and placed inside another folder called the target. This also affects all the files inside and can break things, expecting a backup file in a fixed location. So, you must always confirm paths before pressing Enter.

Batch Rename with rename

The rename command helps you update multiple files and directories in one step. It works best when you need consistent naming across many items in the same directory or path. You control how names change using patterns. This Linux command tool updates each filename or directory name in place.

Installation

Install the package first if it is missing from your system.

For Ubuntu or Debian:

sudo apt install rename

For CentOS or RHEL:

sudo yum install prename

When the installation is complete, just type “rename“in the terminal to confirm it exists.

Perl Regex Syntax

The command uses search and replace. This example replaces “old” with “new” in directory names:

rename 's/old/new/' directories

You can also change characters and case. This converts uppercase to lowercase:

rename 'y/A-Z/a-z/' *

To see what will change before applying it, use verbose mode.

rename -v 's/v1/v2/' *

We can now see the output for every updated file or folder, so you can confirm results before exiting.

Search and Rename with find

The find command is very useful when you don’t really know the location of a folder, file, or directory. It also helps developers find something when there are multiple files with the same name. It’s applicable mainly when developers are dealing with large servers.

You combine find with mv to search first, then apply a controlled change using some clear arguments.

Renaming with -exec and mv

First, you need to search for a directory and rename it. It all happens with a single line of code.

This example finds a folder named old_folder and renames it:

find . -type d -name "old_folder" -exec mv {} new_folder \;

Here, we pretty much prompt the system to pass each of the results to “mv” for the renaming process. It works best when you’re in a project folder, the home directory, or even when inside a shared space.

Safer execution with -execdir

A useful tool is “-execdir“, which you can use to run the “rename” operation inside the folder where the match exists. This ultimately reduces the risk of potential path-related error when folders share names.

Here’s how it goes:

find . -type d -name "temp" -execdir mv {} temp_backup \;

This forces the operation to remain local to each parent directory.

Rename All Matching Directories

To rename all matching directories in bulk, you can point, for example, every folder ending with _old by removing the suffix:

find ~/Desktop -type d -name "*_old" -execdir mv {} old \;

You target the desktop, match by pattern, and apply a single naming rule. This method provides a clear answer to large cleanup tasks. It all happens without manually opening each folder or writing paths.

Common Issues When Renaming:

If you’ve already tried to rename files, the system has probably blocked some of your operations. This is because of a logic, permission, or usage issue. This mainly happens on servers and shared machines.

So, we’re going over the top 3 cases in which the system will block your operation.

1. Permission Denied

This happens when your user lacks write access to the folder or its parent directory.

The solution is to check the permissions:

ls -l

If the owner is different, run the command with sudo:

sudo mv old_folder new_folder

Note: Only do this when you trust the path and understand the impact.

2. Directory Exists

If, for some reason, the rename operation fails, maybe the targeted file, folder, or directory name is already present somewhere in the filesystem.

So, first check:

ls

Try to delete the existing folder with that name, try a different name, or move the old one elsewhere.

3. Directory In Use

If there is a running process from the directory you’re trying to move or rename, the operation will fail.

So, find what is using the directory:

lsof +D directory_name

To fix this, stop the process, then rename the folder. This will avoid partial moves and corrupted paths.

Summary and Next Steps with ServerMania

You now have three solid ways to rename directories:

Use mv for fast single changes that only affecting single item.
Use rename for big batch updates across many files or folders.
Use find for unknown paths/when names repeats in filesystem.

💡Reminder: After every change, run ls to confirm the result.

If you manage production systems, reliable file operations matter!

ServerMania provides high-performance Linux server hosting through our dedicated servers and cloud platform (AraCloud). You get stable environments built for clean directory structures, automation, and safe administration at scale. The full control we provide allows you to alter storage, permissions, and filesystem layouts for automation and safe administration.

See Also: Why Use Linux for Server Hosting

💬If you’re curious to learn more about our Linux servers, get in touch with our 24/7 customer service or book a free consultation with Linux experts. We’re available right now!

How to Rename a Directory in Linux: Command Guide with Examples