Home Beginner's Guide How to Rename Files in Linux with Command-Line Tools

How to Rename Files in Linux with Command-Line Tools

Renaming files in Linux through the command line is a fundamental skill for efficient file management. This guide provides a comprehensive overview of how to use commands like mv and rename, complete with examples, to streamline your workflow and keep your directories organized.

by Divya Kiran Kumar
Published: Updated:
Rename files command-line linux

In this guide, we delve into the art of renaming files using the command line, a task that might seem mundane but is foundational to efficient file management. From the basics of using mv for simple renames to leveraging advanced tools like rename, awk, sed, and even scripting for bulk operations, we cover a wide range of techniques. We navigate through handling files with spaces and special characters, renaming directories, ensuring safety with backups, and provide tips for both beginners and advanced users.

Renaming files in Linux using command-line

The basics of mv

At its simplest, renaming a file in Linux can be done with the mv (move) command. Yes, you heard that right. In Linux, moving and renaming are essentially the same operation—just moving a file to the same location with a new name. The syntax is as follows:

mv [options] source target


Suppose you have a file named OldName.txt and you want to rename it to NewName.txt. Here’s how you’d do it:

mv OldName.txt NewName.txt

This command is straightforward and works well for individual files. However, my gripe with mv is when it comes to renaming multiple files at once. It doesn’t support wildcards for the target name, which leads us to other tools for batch renaming.

Batch renaming with rename

The rename command is where things get interesting (and a bit more complex). It allows for renaming multiple files based on patterns and regular expressions. The basic syntax is:

rename [options] 's/oldpattern/newpattern/' files


Imagine you have several files in a directory named file1.txt, file2.txt, file3.txt, and so on, and you want to change the file part of the names to document. Here’s how you’d use rename:

rename 's/file/document/' *.txt

This command will change the names of the files to document1.txt, document2.txt, document3.txt, etc. It’s powerful and efficient, especially for large batches of files. My personal beef with rename, though, is that it can be somewhat intimidating for beginners due to its use of regular expressions. However, once you get the hang of it, it’s incredibly powerful.

Advanced renaming with scripts

For those who really want to dive deep and have full control over renaming files, writing a small bash script can be the way to go. This approach allows for complex logic, such as conditional renaming, iterating over files with loops, and using a mix of other command-line tools.

Sample script

Here’s a simple script that renames files based on a condition:


for file in *.txt; do
  if [[ $file == file* ]]; then
    mv "$file" "new_${file}"

This script loops through all .txt files in the current directory, and if the file name starts with file, it renames it by prefixing it with new_. It demonstrates the power of scripting but also highlights my slight frustration with bash scripting: it can get complicated quickly, and syntax errors are easy to make.

Dealing with spaces and special characters

One of the trickier aspects of working with files in Linux, especially for newcomers, is handling file names with spaces and special characters. It’s a common stumbling block but fear not—I have some tips to make this easier.

Quoting file names

When working with file names that contain spaces, it’s important to quote the name or use escape characters. This tells the shell to interpret the spaces as part of the file name rather than as separators between arguments.

Example with spaces
mv "old file name.txt" "new file name.txt"

Or using escape characters:

mv old\ file\ name.txt new\ file\ name.txt

Special characters

Special characters, such as *, ?, [, ], and !, can also cause issues because they have special meanings in the shell. To deal with these, you can also use quotes or escape characters.

Example with special characters
mv "file[1].txt" "document[1].txt"


mv file\[1\].txt document\[1\].txt

Handling spaces and special characters properly will save you from many a headache and is a crucial skill for any Linux user.

Renaming directories

Renaming directories is just as straightforward as renaming files, but it’s worth mentioning because directories are such a fundamental part of navigating and organizing in Linux.

Using mv to rename directories

The mv command works for directories just like it does for files:

mv old_directory_name new_directory_name

This command will rename the directory old_directory_name to new_directory_name. Just remember, if the new directory name exists and is not empty, mv will throw an error unless you use specific options to handle this situation.

Safety tips for batch renaming

When you’re performing batch operations, especially renaming, it’s easy to make mistakes that can be hard to undo. Here are a couple of tips to help avoid disaster:

Preview your changes with rename

The rename command often supports a -n or --no-act option, which shows what changes it would make without actually doing anything. This is incredibly useful for making sure your command does what you expect before you let it loose on your files.

rename -n 's/file/document/' *.txt

This command will show the changes it would make to the file names without actually renaming them.

Advanced renaming techniques for power users

For those who have mastered the basics and are looking for more control and efficiency in their file management tasks, Linux offers powerful tools and techniques. This section delves into advanced renaming techniques that leverage the full potential of the command line.

Using find and xargs for complex renaming tasks

Combining find with xargs and mv can be a powerful way to rename files based on complex criteria, such as file type, size, or modification date.

Example: Renaming all .jpeg files to .jpg in a directory and its subdirectories
find . -type f -name "*.jpeg" -print0 | xargs -0 rename 's/\.jpeg$/.jpg/'

This command uses find to search for all files ending in .jpeg, then pipes the list of files to rename through xargs, ensuring even filenames with spaces are handled correctly thanks to the -print0 and -0 options.

Using awk in renaming scripts

awk is a powerful text processing tool that can be used in renaming scripts to manipulate file names based on patterns, fields, or text processing functions.

Example: Adding a prefix to files based on their content
ls *.txt | awk '{print "mv "$0" PREFIX_"$0}' | sh

This snippet lists all .txt files, then uses awk to print a mv command for each file that adds a prefix. The resulting commands are then executed by piping them into sh. This is a simple illustration; awk can be used for much more complex text manipulations.

Scripting with sed for inline renaming

sed, or Stream Editor, is another tool that excels at manipulating text. It can be used in scripts to perform inline edits on file names.

Example: Renaming files by removing specific characters
for file in *.txt; do
  newname=$(echo $file | sed 's/[0-9]//g')
  mv "$file" "$newname"

This script loops through .txt files, using sed to remove all digits from their names, and then renames them accordingly.

Leveraging bash functions for dynamic renaming

For users comfortable with bash scripting, writing custom functions can encapsulate complex renaming logic into reusable commands.

Example: A bash function to rename files with a date stamp
function stamp_rename() {
  for file in "$@"; do
    mv "$file" "$(date +%Y%m%d)_$file"

This function, when added to your .bashrc or .bash_profile, allows you to rename any number of files passed as arguments by prefixing them with the current date.


We’ve seen how simple commands like mv can perform the basic task of renaming, while more complex operations require the use of powerful tools such as rename, find combined with xargs, awk, and sed. Each method offers its unique advantages, whether it’s handling files with tricky names, executing batch renames, or crafting scripts for custom renaming tasks.

You may also like

Leave a Comment



FOSS Linux is a leading resource for Linux enthusiasts and professionals alike. With a focus on providing the best Linux tutorials, open-source apps, news, and reviews written by team of expert authors. FOSS Linux is the go-to source for all things Linux.

Whether you’re a beginner or an experienced user, FOSS Linux has something for everyone.

Follow Us


©2016-2023 FOSS LINUX



“Linux” is the registered trademark by Linus Torvalds in the U.S. and other countries.