How to Rename Files in Linux?

Learning how to rename a file in Linux is a fundamental skill that can enhance your productivity. With the mv command, you have the power to rename files efficiently.

Updated: 31 Mar, 24 by Amelia S 17 Min

List of content you will read in this article:

Renaming files in Linux is a fundamental and often essential task for users seeking to maintain an organized and efficient file system. Knowing how to rename a file in Linux is crucial for effective file management. Whether you need to rename a single file or batch-rename multiple files, Linux provides a rich set of tools and techniques to accomplish this with precision and ease. In this comprehensive guide, we will explore various methods to rename files in Linux, from basic and straightforward commands to advanced techniques that offer unparalleled flexibility.

Whether yo're a Linux newcomer or an experienced user looking to streamline your file management, this guide will equip you with the knowledge and skills to rename files confidently and effectively in the Linux environment.

To rename a file in Linux, you can use the mv command, which stands for "move." The basic syntax for renaming a file is mv oldname.txt newname.txt, where oldname.txt is the current name of the file you want to rename, and newname.txt is the desired new name. You can also use wildcards and combine mv with other commands like find to rename multiple files at once or rename files based on specific criteria. Additionally, advanced techniques such as regular expressions and bash scripting offer more customization options for file renaming in Linux.

🚀 Ready to elevate your Linux skills? Dive into our comprehensive Linux Commands Cheat Sheet for all the shortcuts and commands you need to become a Linux pro!

How to Use the Linux mv Command?

The `mv` command is used in Linux to move files and directories from one location to another. It can also be used to rename files and directories. Here is a basic guide on how to use the `mv` command:

  1. To Move Files:

The basic syntax for moving files is:

mv [options] source destination

Here, `source` is the name of the file you want to move, and `destination` is the path to the directory you want to move it to.


mv myfile.txt /home/username/Documents/

This will move `myfile.txt` to the Documents directory in the `username` home directory.

  1. To Rename Files:

To rename a file, you use the `mv` command followed by the current file name and the new file name.

mv oldname.txt newname.txt


mv oldresume.doc newresume.doc

This will rename the file `oldresume.doc` to `newresume.doc`.

  1. Options:
  • `-i` (interactive): Prompts you before overwriting an existing file.
  • `-u` (update): Moves only when the source file is newer than the destination file or when the destination file is missing.
  • `-v` (verbose): Shows the names of the files as they are being moved.
  • `-n` (no clobber): Prevents an existing file from being overwritten.

Example with options:

mv -i oldname.txt newname.txt

This will ask for confirmation before overwriting `newname.txt` if it already exists.

  1. Moving Multiple Files:

You can move multiple files by specifying more than one source file followed by a directory as the destination.


mv file1.txt file2.txt file3.txt /home/username/Documents/

This moves `file1.txt`, `file2.txt`, and `file3.txt` to the Documents directory.

  1. Using Wildcards:

You can also use wildcards (like `*`) to move multiple files that match a pattern.


mv *.txt /home/username/Documents/

This moves all `.txt` files to the Documents directory.

  1. Moving Directories:

You can move a directory in the same way you move a file.


mv /path/to/olddir /path/to/newdir

If `newdir` doesn't exist, `olddir` will be renamed to `newdir`. If `newdir` exists, `olddir` will be moved into `newdir`.

Always be careful when using the `mv` command, especially when logged in as the root user, because you can overwrite important files or directories. It's a good practice to use the `-i` option to prevent accidental overwriting.

Utilizing the `rename` Command for File Renaming in Linux

The `rename` utility in Linux is a potent command-line tool designed for batch renaming of files and directories. Unlike the simpler `mv` command, `rename` leverages Perl expressions to provide a versatile renaming capability, necessitating a foundational understanding of Perl's syntax and operations.

🤓 Become a Linux command line wizard! Explore our step-by-step guide on using the "Linux Rename Command" to manage your files like a pro.

Installation of the `rename` Utility

By default, `rename` may not be present on all Linux systems. If it's missing from your distribution, you can easily install it using the package manager as follows:

For Ubuntu and Debian-based systems:

  sudo apt install rename

For Red Hat-based systems (CentOS, Fedora):

  sudo yum install prename

For Arch Linux and its derivatives:

  sudo pacman -S rename

Syntax and Usage of `rename`

The `rename` command primarily utilizes substitute (`s///`) and translate (`y///`) expressions for renaming files and directories.

Substitute Expressions:

This form is utilized for replacing specific patterns within filenames:

rename [options] 's/[search_pattern]/[replacement]/' [file(s)]

Here’s what each part of the syntax represents:

  `s/`: Signifies the beginning of a substitute expression.

  `[search_pattern]/[replacement]/`: Defines the pattern to find and the string to replace it with.

  `[file(s)]`: Specifies the files to be renamed.

Translate Expressions:

Translate expressions perform character-by-character substitutions:

rename [options] 'y/[set1]/[set2]/' [file(s)]

An example is as follows:

rename 'y/abc/xyz/' *

This example changes each 'a' to 'x', 'b' to 'y', and 'c' to 'z' in the file names.

Options for Enhanced `rename` Command Functionality

  • `-a` (All occurrences): Substitutes all instances of the pattern in the file names instead of just the first.
  • `-f` (Force): Overwrites existing files without prompting.
  • `-h` (Help): Prints out the help manual for the command.
  • `-i` (Interactive): Prompts before overwriting any files, ensuring a layer of safety.
  • `-l` (Last): Targets the last occurrence of the specified pattern within the file name for replacement.
  • `-n` (No action): Executes the command in a test mode, showing what changes would be made without actually performing them. Pair with `-v` for detailed output.
  • `-s` (Symlink): Operates on the symlink itself rather than the file it points to.
  • `-v` (Verbose): Outputs the detailed process of the renaming operation, indicating clearly what changes are being made.
  • `-V` (Version): Displays the installed version of the `rename` command.

Practical Tips for Using `rename`

  • Always perform a dry run (`-n`) when working with unfamiliar patterns to prevent undesired changes.
  • Utilize the interactive mode (`-i`) when overwriting files to maintain control over the process.
  • For complex renaming tasks, break down the operation into smaller, testable units to ensure accuracy.
  • Read the `rename` man page (`man rename`) or the help text (`rename -h`) for comprehensive instructions and advanced features.

In essence, the `rename` command is a flexible and efficient means of renaming files in bulk, provided the user is equipped with the necessary Perl regex knowledge. With the variety of options and the power of regular expressions, `rename` can handle nearly any batch rename task you may encounter.

So you might ask what command is used to rename a file in Linux when we have multiple files. Renaming multiple files in Linux can be efficiently accomplished using the mv command in combination with various techniques. To rename multiple files simultaneously, you can leverage the power of wildcards, which are symbols representing patterns of characters. For instance, the asterisk * wildcard matches any sequence of characters, while the question mark matches a single character. This enables you to perform batch renaming operations with ease.

For example, for Linux rename file in different directory with the ".txt" extension to have a ".pdf" extension, you can execute the command mv *.txt *.pdf, effectively changing the file extensions for all matching files.

If you need more control over the renaming process, you can use loops or the find Linux rename a file command in combination with mv. A common approach is to use a for loop in a bash script to iterate through a set of files and rename them according to your desired pattern. For instance, you can create a bash script that renames all files in a directory to have a prefix or suffix, adding a timestamp, or any other customized format.

Rename Multiple Files With the mv Command

While the `mv` command in Linux is fundamentally designed for moving files from one location to another, it can also be employed to rename files. However, unlike the `rename` command, `mv` doesn't inherently handle batch renaming and requires manual execution for each file or a loop in a shell script.

Single File Rename with `mv`:

Renaming a single file is straightforward with the `mv` command:

mv old_filename new_filename

Here, `old_filename` is the current name of the file, and `new_filename` is the desired new name.

Batch Renaming With a Loop:

For renaming multiple files, you can loop through each file using a for loop or find a pattern and execute `mv` for each item:

for old_name in pattern; do

    new_name="$(echo "$old_name" | some_transformation)"

    mv "$old_name" "$new_name"


Replace `pattern` with a shell glob or pattern that matches the files you want to rename, and `some_transformation` with the command or operations that generate the new name.

Examples of Batch Renaming:

  1. Prefix Addition:

To add a prefix to a series of `.txt` files:

for file in *.txt; do

mv "$file" "prefix_$file"


  1. Extension Change:

To change file extensions from `.jpeg` to `.jpg`:

for file in *.jpeg; do

mv "$file" "${file%.jpeg}.jpg"


  1. Date Removal from Filenames:

If filenames start with a date in the format `YYYY-MM-DD_`, you can remove the date:

for file in 202?-??-??_*.mp4; do

mv "$file" "${file:11}"


  1. Sequential Numbering:

For adding sequential numbers to files:


for file in *.mp3; do

mv "$file" "$(printf "track_%02d.mp3" "$a")"



Tips for Safe Use of `mv` for Renaming:

  • Always verify the target filename does not exist unless you intend to overwrite.
  • Use `mv -i` to prompt for confirmation before overwriting any files.
  • Test the commands with `echo` instead of `mv` first to ensure they'll rename as expected.
  • Back up files or directories before performing batch operations to prevent data loss.
  • When dealing with spaces or special characters in filenames, quote variables (`"$file"`) to prevent unexpected behavior.

By creatively using shell loops and other command-line utilities for string manipulation, the `mv` command can be quite powerful for batch renaming tasks, though it may require a bit more manual setup compared to using `rename`.

Wildcards are powerful symbols that represent patterns of characters. They enable you to rename multiple files based on specific criteria. Here are a couple of examples:

  • The * wildcard matches any sequence of characters.
  • The ? wildcard matches a single character.

You can perform batch renaming operations efficiently by combining wildcards with the mv command. For instance, to rename all files starting with "photo" to include a date stamp, you can use the following command:

mv photo*.jpg 2023-06-13_photo*.jpg

Linux provides various options for renaming files based on specific criteria, such as file size, modification date, or permissions. The find command, in combination with mv, allows you to search for files that meet certain conditions and rename them accordingly.

In this how to rename a file in Linux example, to rename all files larger than 10MB in the current directory, you can use the following command:

find . -type f -size +10M -exec mv {} large_files/

Renaming files in subdirectories is similar to the normal Linux rename file in directory. Using the appropriate options with the find command, you can search for files in specific directories and perform renaming operations, demonstrating how to rename a file in Linux terminal efficiently.

For instance, to rename all files with the ".png" extension in a subdirectory called "images," you can use the following rename a file in Linux command line:

find images/ -name "*.png" -exec mv {} new_images/

Undoing file renaming in Linux can be a bit challenging, but it's possible with the right precautions and strategies. The key to successfully reverting file renaming operations is having a backup or record of the original file names. If you have a backup, you can simply move the files back to their original names using the mv command.

However, if you don't have a backup, you might need to resort to file recovery tools or rely on version control systems if available. Some file recovery tools like TestDisk or PhotoRec can help you recover lost or renamed files, but success may vary depending on the circumstances. Additionally, if you're working within a version control system like Git, you can use Git's history to track and revert changes, including file renames.

So, whether you're asking “how can i rename a file in Linux” or find yourself needing to undo a file renaming operation, understanding how can you rename a file in Linux is a valuable skill that can save you time and effort in managing your files effectively.

Advanced techniques for file renaming in Linux provide users with a high degree of flexibility and customization options. These methods are particularly useful for intricate renaming tasks or when you need to automate complex operations.

  1. Using Regular Expressions: Regular expressions (regex) are powerful patterns that allow you to match and manipulate text. They are invaluable when dealing with complex renaming tasks. Tools like rename or sed support regular expressions, enabling you to perform intricate file-renaming operations. This level of precision can save a significant amount of time when dealing with large datasets or when specific renaming patterns need to be applied.
  2. Writing Bash Scripts for Renaming: Bash scripting is a versatile way to automate complex and repetitive renaming tasks. By creating custom bash scripts tailored to your needs, you can combine Linux commands and scripting constructs to perform intricate renaming operations. For instance, you can create a bash script that iterates through a directory, identifies files that meet specific criteria (e.g., file size, date of creation), and renames them accordingly.
  3. Utilizing Third-party Tools: While Linux provides robust native utilities for file renaming, there are also third-party tools and applications available that can simplify and enhance the process. Programs like "Thunar Bulk Rename" for the Thunar file manager or "KRename" offer user-friendly interfaces and advanced features for batch renaming files. These tools can be especially helpful for users who prefer graphical interfaces or require additional functionality beyond what the command line provides.
  4. Version Control Systems (VCS): If you are working within a version control system like Git, it offers a unique advantage for tracking and managing file renames. Git maintains a history of file changes, including renames, making it easy to revert renaming operations or trace the evolution of file names over time. You can use Git's commands like git mv and git log to handle file renaming within the context of your version control workflow.

Learning how to rename a file in Linux is a fundamental skill that can enhance your productivity and organization. With the versatile mv command, wildcards, and advanced techniques like regular expressions and scripting, you have the power to rename files efficiently and in bulk. Always remember to exercise caution and maintain backups to avoid unintended consequences.

Whether you're a Linux enthusiast or a system administrator, mastering file renaming in Linux is an essential skill that can save you time and effort in managing your files and directories. For those interested in Linux VPS hosting, consider checking out affordable options like Cheap Linux VPS Hosting.

So go ahead, explore the various methods of renaming files in Linux, and unlock your potential in the world of Linux file management!

The rename command in Linux is a command-line utility used for renaming multiple files at once according to a specified set of rules. This can include simple name changes or more complex pattern-based renames using regular expressions.

To rename a file in general, you can simply change the name manually in a file explorer or use a command-line tool. On the command line, you typically use the mv (move) command to rename a file by moving it to the same directory with a new name.

In Linux, you can rename a file using the mv command. The syntax is: mv old_filename new_filename. This will rename old_filename to new_filename. If new_filename already exists, it will be overwritten unless you use the -i option which prompts for confirmation before overwriting.

To rename a file in Linux using the mv command, you can follow the simple syntax mentioned earlier: mv old_filename new_filename. This is a straightforward way to rename files, but if you need to rename multiple files according to a pattern, you might need to use the rename command or write a small script that uses mv in a loop with conditionals to handle the renaming.