How to Rename Files on Linux using Terminal

Renaming files is one of the most common file management tasks when working with Linux systems. While graphical file managers offer convenient options, the terminal provides unparalleled flexibility, efficiency, and automation capabilities for file manipulation. Whether you’re organizing a collection of documents, standardizing filenames across a project, or batch processing thousands of files, understanding terminal-based renaming techniques is essential for anyone serious about Linux.

This guide explores various methods to rename files in Linux using the terminal, covering everything from basic commands to advanced techniques with regular expressions. By mastering these approaches, you’ll enhance your productivity and gain deeper insight into Linux file management fundamentals.

Understanding Linux File System Basics

Before diving into specific commands, it’s important to understand how Linux handles filenames. Unlike Windows, Linux filesystems are case-sensitive, which means “document.txt,” “Document.txt,” and “DOCUMENT.txt” are treated as three distinct files. Linux allows almost any character in filenames except the forward slash (/) which serves as the directory separator.

The Linux philosophy treats renaming as a special case of moving a file. When you rename a file, you’re essentially moving it to a new name in the same location. This explains why Linux doesn’t have a dedicated “rename” command in its core utilities but instead uses the “mv” (move) command for basic renaming operations.

File paths can be specified in absolute terms (starting from the root directory) or relative terms (in relation to the current working directory). Understanding this distinction is crucial when renaming files in different locations.

Basic File Renaming with the mv Command

What is the mv Command?

The mv (move) command is the standard utility for both moving and renaming files in Linux systems. Its basic syntax is straightforward:

mv [options] source destination

Several options enhance the functionality of mv:

• -v (verbose): Shows what’s happening during the operation
• -i (interactive): Prompts before overwriting
• -n (no-clobber): Prevents overwriting existing files
• -b (backup): Creates backups of files before overwriting

These options help prevent accidental data loss and provide better visibility into the renaming process.

Step-by-Step Examples

Renaming a single file in the current directory requires just the original and new filenames:

mv oldfile.txt newfile.txt

You can verify the operation’s success by listing the directory contents:

ls -l

When working with files in different locations, you can use absolute or relative paths:

# Using absolute paths
mv /home/user/documents/draft.doc /home/user/documents/final.doc

# Using relative paths
mv ./notes/ideas.md ./notes/project-outline.md

This flexibility allows precise control over file locations during renaming operations.

Moving and Renaming Simultaneously

One of mv’s powerful features is the ability to move and rename a file in a single operation:

mv ~/downloads/data.csv ~/projects/analysis/processed-data.csv

This command moves “data.csv” from the downloads directory to the analysis directory while simultaneously renaming it to “processed-data.csv”. This capability streamlines workflow when reorganizing files across a directory structure.

Handling Special Cases with mv

Working with Spaces in Filenames

Filenames containing spaces require special handling since spaces typically separate command arguments:

# Using quotes
mv "old file name.txt" "new file name.txt"

# Using escape characters
mv old\ file\ name.txt new\ file\ name.txt

Both approaches work effectively, but quotes are generally easier to read and less prone to errors. Double quotes allow for variable expansion within the filename, while single quotes preserve the literal text.

Special Characters in Filenames

Beyond spaces, filenames might contain special characters that have meaning to the shell:

# Renaming a file with symbols
mv "report(2023).pdf" "annual_report_2023.pdf"

# Handling files with exclamation marks
mv 'urgent!notice.txt' 'urgent_notice.txt'

For truly problematic filenames (like those starting with hyphens), use -- to signify the end of options:

mv -- -strange-filename.txt normal-filename.txt

This technique prevents the shell from interpreting the hyphen as a command option.

Hidden Files

In Linux, files beginning with a dot (.) are considered hidden. Renaming these files follows the same pattern as regular files:

# Keeping a file hidden
mv .config.old .config.backup

# Making a hidden file visible
mv .secret.txt visible_now.txt

When working with hidden files, use ls -a to verify the results of rename operations.

Batch Renaming with the mv Command

Using Loops for Batch Operations

For renaming multiple files following a pattern, shell loops provide an efficient solution:

# Basic for loop to add prefix to multiple files
for file in *.jpg; do
    mv "$file" "vacation-$file"
done

This example adds the prefix “vacation-” to all JPEG files in the current directory. For more complex operations, while loops offer additional flexibility:

# Using while loop with read
ls *.txt | while read filename; do
    mv "$filename" "${filename%.txt}.md"
done

This script converts all text files to markdown format by changing their extensions.

Working with Wildcards

Wildcards expand the versatility of batch renaming operations:

# Using * wildcard to match multiple files
mv *.html pages/

# Using ? wildcard for single character matching
mv photo?.jpg renamed/

The asterisk (*) matches any number of characters, while the question mark (?) matches exactly one character. Combining these creates powerful selection criteria for batch operations.

Practical Examples

Consider the task of renaming a series of numbered files to add leading zeros:

# Renaming files to ensure proper sorting
for i in {1..9}; do
    mv "image$i.png" "image00$i.png"
done

for i in {10..99}; do
    mv "image$i.png" "image0$i.png"
done

For changing multiple file extensions at once:

# Converting all .jpeg files to .jpg
for file in *.jpeg; do
    mv "$file" "${file%.jpeg}.jpg"
done

Error handling during batch operations prevents data loss:

for file in *.txt; do
    if [ -e "${file%.txt}.doc" ]; then
        echo "Warning: ${file%.txt}.doc already exists, skipping $file"
    else
        mv "$file" "${file%.txt}.doc"
    fi
done

This script checks for existing files before performing the rename operation.

Advanced Renaming with the rename Command

Introduction to the rename Utility

While mv excels at simple renaming tasks, the rename command provides specialized functionality for complex pattern-based renaming. However, there are two distinct versions of this command across Linux distributions:

1. The Perl-based rename (commonly found in Debian, Ubuntu, and derivatives)
2. The util-linux rename (common in Red Hat, Fedora, and some other distributions)

To determine which version is installed on your system, check the man page:

man rename

If the rename command isn’t available, it can be installed on most distributions:

# On Debian/Ubuntu for Perl version
sudo apt install rename

# On Red Hat/Fedora for util-linux version
sudo dnf install util-linux-user

Basic rename Syntax

For the Perl version (more common and powerful), the basic syntax follows a regular expression substitution pattern:

rename 's/old-pattern/new-pattern/' files

This structure leverages Perl’s search and replace functionality. For example:

# Replace spaces with underscores in all text files
rename 's/ /_/g' *.txt

The ‘g’ flag ensures all occurrences of spaces are replaced, not just the first one.

The util-linux version uses a different syntax:

rename old-pattern new-pattern files

For example:

# Replace .txt with .md
rename .txt .md *.txt

Command Options

The Perl version of rename offers several useful options:

# Verbose mode to see what's happening
rename -v 's/\.jpeg$/.jpg/' *.jpeg

# Test mode to preview changes without executing them
rename -n 's/img_/image_/' *.png

# Force option to override warnings
rename -f 's/old/new/' files

The test mode (-n) is particularly valuable for complex renaming operations, allowing you to verify the expected outcome before committing changes.

When to Use rename Instead of mv

The rename command shines in scenarios requiring:

1. Pattern-based search and replace across multiple filenames
2. Complex transformations using regular expressions
3. Bulk operations on large numbers of files

For simple one-off renames, mv remains more straightforward. However, when dealing with datasets containing hundreds or thousands of files requiring systematic naming changes, rename offers superior efficiency and precision.

Regular Expressions for Powerful Renaming

Regex Basics for Filename Manipulation

Regular expressions unlock the full potential of the rename command. Understanding key regex concepts is essential for effective filename manipulation:

Basic pattern matching includes:

• . – Matches any single character except newline
• ^ – Matches the start of a string
• $ – Matches the end of a string
• [abc] – Matches any character in the brackets
• [^abc] – Matches any character NOT in the brackets

Quantifiers control how many times a pattern should match:

• * – Match 0 or more times
• + – Match 1 or more times
• ? – Match 0 or 1 time
• {n} – Match exactly n times
• {n,m} – Match between n and m times

Substitution Expressions

Substitution expressions form the core of rename operations:

# Replace all instances of 'photo' with 'image'
rename 's/photo/image/g' *.jpg

# Case-insensitive search and replace
rename 's/report/document/i' *.txt

Capturing groups enable more complex transformations:

# Rearrange date format from YYYY-MM-DD to DD-MM-YYYY
rename 's/(\d{4})-(\d{2})-(\d{2})/\3-\2-\1/' *.txt

In this example, parentheses create three capturing groups for year, month, and day, which are then rearranged in the replacement pattern.

Translation Expressions

The translate (y///) operation performs character-by-character replacement:

# Convert lowercase filenames to uppercase
rename 'y/a-z/A-Z/' *.txt

This is particularly useful for case conversion operations:

# Convert first letter to uppercase, rest to lowercase
rename 's/(.)/\u$1/g' *.txt
rename 's/(\w)(\w*)/\u$1\L$2/g' *.txt

The special escape sequences \u (uppercase next character), \l (lowercase next character), \U (uppercase all following characters), and \L (lowercase all following characters) provide precise control over case transformations.

Complex Pattern Matching

Combining multiple regex techniques enables sophisticated renaming operations:

# Extract date from filename and reformat
rename 's/.*_(\d{4})(\d{2})(\d{2})_.*/$1-$2-$3_report.pdf/' *.pdf

# Remove anything in parentheses including the parentheses
rename 's/\s*\([^)]*\)//g' *.mp3

For truly complex operations, breaking the process into multiple rename commands often proves more readable and maintainable than crafting a single intricate expression.

Real-World Use Cases

Changing File Extensions

One of the most common renaming tasks involves converting between file extensions:

# Simple extension change
rename 's/\.txt$/.md/' *.txt

# Handling files with multiple dots
rename 's/(.*)\.old\.bak$/$1.new/' *.old.bak

For image files, automating format conversions streamlines workflow:

# Standardize image extensions
rename 's/\.(jpeg|JPEG|JPG)$/.jpg/' *

This example converts various JPEG format extensions to a standardized lowercase .jpg extension.

Adding Prefixes or Suffixes

Adding contextual information through prefixes enhances file organization:

# Add date prefix to files
rename 's/^/2023-03-24_/' *.log

# Add project identifier to all documents
rename 's/^/PROJECT-X_/' *.docx

Similarly, suffixes can categorize or version files:

# Add version suffix
rename 's/\.txt$/_v1.txt/' *.txt

# Add processing status
rename 's/^(.*)$/$1_REVIEWED/' *.pdf

Timestamps provide particularly useful context for logs and backups:

# Add current date as suffix
today=$(date +%Y%m%d)
rename "s/(.*)/$1_$today/" *.bak

Removing Parts of Filenames

Cleaning up filenames by removing unwanted elements improves readability:

# Remove text in square brackets
rename 's/\s*\[.*?\]//g' *.mp3

# Strip unwanted prefixes
rename 's/^unwanted_//' *.csv

For downloaded files that often contain extraneous information:

# Clean up downloaded videos
rename 's/^Download_-_//' *.mp4

# Remove tracking IDs
rename 's/_id[0-9]{8}//' *.pdf

Case Conversion

Standardizing filename case ensures consistency across projects:

# Convert to lowercase for web files
rename 'y/A-Z/a-z/' *.html

# Capitalize first letter of each word
rename 's/(\w+)/\u$1/g' *.txt

Mixed case handling requires more sophisticated patterns:

# Convert camelCase to snake_case
rename 's/([a-z0-9])([A-Z])/$1_\l$2/g' *.java

Replacing Spaces with Underscores

Web-friendly filenames typically avoid spaces:

# Basic space replacement
rename 's/ /_/g' *

# Handle multiple spaces and special characters
rename 's/\s+/_/g' *

Other delimiters can be managed similarly:

# Replace hyphens with underscores
rename 's/-/_/g' *

# Standardize different separators
rename 's/[-\s.]/_/g' *

Using Other Tools for Renaming

mmv Utility

The mmv (multiple move) utility specializes in simultaneous file operations with wildcard patterns:

# Install mmv
sudo apt install mmv   # Debian/Ubuntu

# Basic usage
mmv "*.txt" "#1.md"

The special syntax uses #1, #2, etc., as placeholders for matched patterns. For example:

# Rename all chapter_N.doc to section_N.docx
mmv "chapter_*.doc" "section_#1.docx"

This tool excels at operations involving multiple wildcards in both source and destination patterns.

pyRenamer

For users who prefer graphical interfaces with terminal integration, pyRenamer offers a user-friendly approach:

# Install pyRenamer
sudo apt install pyrenamer   # On Debian/Ubuntu

The tool provides pattern-based renaming with a preview feature, making it accessible for users less comfortable with command-line operations while still leveraging the power of regular expressions.

Using find with exec

The find command combined with -exec creates flexible renaming workflows based on complex criteria:

# Find and rename files based on modification time
find . -type f -name "*.log" -mtime +30 -exec mv {} {}.old \;

# Complex filtering and renaming
find . -type f -size +10M -exec bash -c 'mv "$0" "${0%.jpg}_large.jpg"' {} \;

This approach allows filtering files by attributes like size, modification time, or permissions before renaming them, enabling highly targeted operations.

Best Practices and Tips

Testing Before Execution

When performing complex or batch renaming operations, always test first:

# Preview rename operations
rename -n 's/pattern/replacement/' files

# Echo commands before executing in loops
for file in *.jpg; do
    echo "Would rename $file to image_$file"
    # mv "$file" "image_$file"  # Uncomment after verification
done

Creating a separate test directory with sample files provides a safe environment for experimenting with complex patterns:

mkdir test-rename
cp some-files* test-rename/
cd test-rename
# Test renaming operations here

Backup Strategies

Before mass rename operations, create backups to prevent data loss:

# Simple directory backup
cp -r project project_backup

# Use tar for archives
tar -czf project_before_rename.tar.gz project/

Version control systems offer an additional safety net for important files:

# If using git
git add .
git commit -m "Before mass rename operation"
# Perform renaming
git status  # Review changes

Performance Considerations

For large directories with thousands of files, consider performance optimization:

# Limit scope with more specific patterns
rename 's/old/new/' *.txt  # Instead of rename on all files

# Use find to process in manageable batches
find . -name "*.jpg" -print0 | xargs -0 -n 100 rename 's/pattern/replacement/'

Resource usage awareness becomes important for system-wide operations:

# Schedule intensive operations during off-hours
nice -n 19 find /large/directory -type f -name "*.log" -exec mv {} {}.processed \;

Troubleshooting Common Issues

Permission Denied Errors

Permission issues commonly disrupt renaming operations:

# Check file ownership and permissions
ls -la file.txt

# Change ownership if needed
sudo chown username:groupname file.txt

# Modify permissions
chmod 644 file.txt

When working across directories with mixed permissions:

# Find files you can't modify
find . -type f ! -writable -name "*.txt"

# Use sudo for system files (with caution)
sudo mv /etc/config.old /etc/config.bak

Remember that using sudo should be reserved for system files where absolutely necessary.

Filename Conflicts

Handling existing destination files requires careful planning:

# Check if destination exists before renaming
[ -e "newname.txt" ] && echo "File exists, cannot rename"

# Create unique names with timestamps
mv file.txt file_$(date +%s).txt

To prevent data loss during batch operations:

# Interactive mode prompts before overwriting
mv -i oldfile newfile

# No-clobber mode prevents overwriting
mv -n *.txt destination/

Escaping Issues

Special characters in filenames can cause unexpected behavior:

# List filenames with problematic characters
find . -name "*[*" -o -name "*]*" -o -name "*?*"

# Use printf to handle special cases
filename="strange*file.txt"
newname="normal_file.txt"
printf "mv %q %q\n" "$filename" "$newname" | bash

Terminal interpretation challenges often involve quoting:

# Different quoting methods
mv '$PATH.txt' 'path.txt'  # Literal $PATH
mv "$HOME.txt" "home.txt"  # Expands to home directory