How to Move Files in Linux with mv Command

Published July 08, 2024

The mv command in Linux moves and renames files and directories. This article explains how to use mv, covering basic syntax, moving files and directories, renaming operations, and advanced options. It also provides tips for avoiding common mistakes and handling permissions when using the mv command.

What Is the mv Command?

The mv command in Linux is a tool used for moving and renaming files and directories. It's a basic command that helps users manage their file system.

Basic Syntax of mv

The basic syntax of the mv command follows this structure:

mv [options] source destination
  • mv is the command itself
  • [options] are optional flags that change the command's behavior
  • source is the file or directory you want to move or rename
  • destination is where you want to move the file or directory to, or the new name you want to give it

Moving Files with mv

Moving a Single File

To move a file to a different directory using the mv command, use this syntax:

mv [source_file] [destination_directory]


  1. Move a file to a subdirectory:

    mv report.pdf Documents/
  2. Move a file to a parent directory:

    mv project_notes.txt ../
  3. Move and rename a file:

    mv old_name.txt new_name.txt
  4. Move a file with spaces in its name:

    mv "My Important File.docx" "Important Documents/"

Using the Verbose Option

The -v (verbose) option provides confirmation of the move:

mv -v confidential.txt Secure/
'confidential.txt' -> 'Secure/confidential.txt'

Moving Multiple Files

To move several files at once, list multiple source files before the destination:

mv [file1] [file2] [file3] [destination_directory]

Examples of moving multiple files:

  1. Move specific files:

    mv report1.pdf report2.pdf presentation.pptx Documents/
  2. Use wildcards to move files with a common pattern:

    mv *.jpg Photos/
  3. Move files with a specific prefix:

    mv log_* Logs/
  4. Move files with different extensions:

    mv *.{txt,doc,pdf} Archive/

Verbose Output for Multiple Files

Using the -v option when moving multiple files:

mv -v *.txt Documents/
'note1.txt' -> 'Documents/note1.txt'
'note2.txt' -> 'Documents/note2.txt'
'draft.txt' -> 'Documents/draft.txt'

Advanced mv Usage

Moving Files Safely

To avoid overwriting existing files, use the -i (interactive) option:

mv -i important.txt Documents/
mv: overwrite 'Documents/important.txt'? 

Moving Files Between File Systems

When moving files between different file systems, mv copies the files and deletes the originals:

graph TD A[Source File System] -->|1. Copy| B[Destination File System] A -->|2. Delete Original| C[Empty Space]

Combining mv with Other Commands

Use mv with find to move files based on specific criteria:

find . -name "*.log" -mtime +30 -exec mv {} old_logs/ \;

This command moves all .log files older than 30 days to the old_logs directory.

Common mv Options

Option Description Example
-i Interactive mode (prompts before overwrite) mv -i file.txt Documents/
-n No-clobber (don't overwrite existing file) mv -n *.txt Archive/
-u Update (move only when source is newer) mv -u new_version.txt Projects/
-v Verbose (explain what is being done) mv -v *.doc Reports/
-f Force (overwrite without prompting) mv -f old_file.txt new_location/

Potential Pitfalls

  • Overwriting files accidentally
  • Moving instead of copying (mv removes the source file)
  • Incorrect permissions in the destination directory
  • Moving files across different file systems (may take longer)

Best Practices

  • Double-check the source and destination
  • Use the -i option for important files to prevent accidental overwrites
  • Check that you have the necessary permissions in both source and destination directories
  • For large files or cross-filesystem moves, consider using rsync for better control and resume capability

Renaming Files with mv

Single File Renaming

To rename a file using the mv command:

  1. Open the terminal.
  2. Go to the directory with the file you want to rename.
  3. Use the mv command like this:
mv old_filename new_filename


Scenario Command Description
Update date in filename mv report_2022.pdf report_2023.pdf Changes year in report filename
Add version number mv app.js app_v1.2.js Adds version to JavaScript file
Fix typo mv recieved_docs.txt received_docs.txt Fixes typo in filename

To check the rename, use the ls command:

ls -l new_filename

Renaming Multiple Files

For renaming many files, use mv with wildcards or other commands.

Using Wildcards

To rename all files with a specific extension:

mv *.txt *.doc

This renames all .txt files to .doc files in the current directory.

Using a for Loop

To add a prefix to all .jpg files:

for file in *.jpg; do mv "$file" "vacation_$file"; done

This adds "vacation_" to the start of all .jpg filenames.

Using the rename Command

For more complex renaming:

rename 's/\.html$/\.php/' *.html

This changes the extension of all .html files to .php.

Using mv with find

To rename files in subdirectories:

find . -type f -name "*.log" -exec sh -c 'mv "$0" "${0%.log}.txt"' {} \;

This changes the extension of all .log files to .txt, including in subdirectories.

Working with Directories

Moving Directories

The mv command moves entire directories, including all their contents, while keeping the directory structure. Here are some examples and tips:

Basic Directory Movement

mv /home/user/Documents/Projects /home/user/Backup/

This command moves the "Projects" directory from the Documents folder to the Backup folder.

Moving Multiple Directories

mv Photos Videos Music /media/external_drive/

This example moves three directories (Photos, Videos, and Music) to an external drive.

Handling Directories with Spaces

mv "Annual Reports 2023" "Financial Data/2023 Reports"

When working with directory names containing spaces, use quotation marks.

Verbose Output for Large Moves

mv -v LargeDataSet/ /mnt/nas/Datasets/

The -v option provides verbose output, which is helpful when moving large directories to track progress.

Renaming Directories

Renaming directories with mv is simple but needs attention. Here are some examples:

Simple Directory Rename

mv old_project_name new_project_name

This renames a directory in the current working directory.

Renaming with Full Paths

mv /home/user/Work/Project2022 /home/user/Work/Project2023

This example shows renaming a directory using full paths.

Interactive Renaming

mv -i Drafts FinalDocuments

The -i option asks for confirmation before overwriting an existing directory.

Common Scenarios and Best Practices

Here's a table summarizing common scenarios and best practices when working with directories:

Scenario Best Practice Example
Moving large directories Use rsync for better control and resume capability rsync -av --progress /source/dir/ /dest/dir/
Avoiding overwrite Use -n (no-clobber) option mv -n important_dir/ /backup/
Moving across filesystems Be aware it may take longer; consider using cp then rm cp -R /home/user/data /mnt/newdrive/ && rm -rf /home/user/data
Dealing with permissions Use sudo when necessary sudo mv /opt/app /opt/app_old
Creating backup before move Use cp to create a backup first cp -R project project_backup && mv project /new/location/

Advanced Directory Operations

Bulk Renaming

For bulk renaming of directories, you can use loops in bash:

for dir in Project_*; do
    mv "$dir" "Archive_${dir#Project_}"

This script renames all directories starting with "Project" to start with "Archive" instead.

Moving with Pattern Matching

You can use wildcards to move multiple directories matching a pattern:

mv *_backup /mnt/backup_drive/

This moves all directories ending with "_backup" to the backup drive.

Error Handling and Troubleshooting

Permission Denied Errors

If you get "Permission denied" errors:

  1. Check the directory permissions: ls -l /path/to/directory
  2. Use sudo if you have the necessary rights: sudo mv /restricted/dir /new/location
  3. Change ownership if needed: chown -R user:group /path/to/directory

Disk Space Issues

When moving large directories:

  1. Check available space: df -h
  2. Use du -sh /path/to/directory to estimate required space
  3. Consider using rsync with --partial option for large transfers that might be interrupted

Advanced mv Command Options

Verbose Mode

The -v option in the mv command gives output about the operations. This is useful when moving or renaming multiple files or directories.

To use verbose mode, add the -v flag to your mv command:

mv -v source_file destination_file

Example output:

'source_file' -> 'destination_file'

Benefits of verbose mode:

  • Confirms each file movement or rename operation
  • Helps track progress when moving many files
  • Useful for debugging scripts that use mv


When organizing project files and moving multiple documents to a new folder:

mv -v *.doc /path/to/documents/


'report1.doc' -> '/path/to/documents/report1.doc'
'meeting_notes.doc' -> '/path/to/documents/meeting_notes.doc'
'presentation.doc' -> '/path/to/documents/presentation.doc'

This output helps you verify that all files were moved correctly.

Interactive Mode

The -i option asks for confirmation before overwriting an existing file. This feature helps prevent data loss.

To use interactive mode:

mv -i existing_file new_file

When prompted, respond with:

  • 'y' or 'Y' to confirm the overwrite
  • 'n' or 'N' to skip the operation

Example interaction:

mv: overwrite 'new_file'? y


When updating a configuration file but wanting to avoid overwriting important settings:

mv -i new_config.ini config.ini

If config.ini already exists, you'll see:

mv: overwrite 'config.ini'? 

You can then decide whether to proceed with the overwrite or keep the existing file.

Creating Backups

The --backup option creates a backup of the destination file before overwriting it. This feature provides safety when moving or renaming files.

To create backups:

mv --backup=MODE source_file destination_file

Available backup modes:

Mode Description
none No backups (default if --backup is not specified)
numbered Creates numbered backups
existing Creates numbered backups if numbered backups exist, simple otherwise
simple Always creates simple backups


When updating a critical script and wanting to have backups of previous versions:

mv --backup=numbered /usr/local/bin/

This command creates a backup file like '' before overwriting the original.

Combining Options

You can combine multiple options for more control over file operations:

mv -vi --backup=numbered source_file destination_file

This command will:

  1. Ask for confirmation before overwriting (interactive mode)
  2. Create a numbered backup of the destination file
  3. Provide output of the operation


When updating a database file and wanting to ensure safety:

mv -vi --backup=numbered new_database.sql database.sql

This command will ask you before overwriting, create a numbered backup, and show you the operation performed.

Avoiding Common Mistakes

Preventing Overwriting

The mv command can accidentally overwrite files if not used carefully. To prevent this, use the -n (no-clobber) option.

mv -n source_file destination

This command will not overwrite an existing file at the destination.

Best practices for safe file moves:

  • Use the -n option when moving important files
  • Use the -i (interactive) option to prompt for confirmation before overwriting
  • Create backups before moving many files
  • Use the -v (verbose) option to see what actions are being performed

Example of safe file moving:

mv -nv important_document.txt /path/to/destination/

If a file with the same name exists at the destination, this command will not overwrite it and will show you what happened.

Real-life scenarios:

  1. Moving project files:

    mv -nv project_v1.txt /projects/archive/

    This safely moves a project file to an archive folder without risk of overwriting.

  2. Organizing photos:

    mv -nv *.jpg /photos/2023/

    This moves all JPG files to a 2023 photos folder, preserving any existing files.

  3. Backing up configuration files:

    mv -nv ~/.bashrc ~/.bashrc_backup

    This creates a backup of your bash configuration file without overwriting an existing backup.

Handling Permissions

When moving files between directories with different permissions, you may face issues.

Checking permissions:

ls -l /path/to/source
ls -l /path/to/destination

If you don't have write permissions in the destination directory, use sudo:

sudo mv /path/to/source/file /path/to/destination/

Preserving file permissions:

mv --preserve=mode source_file destination

This command keeps the original file permissions after the move.

Handling ownership and permissions:

  1. Change ownership after moving:

    sudo chown new_owner:new_group moved_file
  2. Adjust permissions if needed:

    chmod 644 moved_file

Moving between filesystems:

rsync -av --remove-source-files source_file destination

This uses rsync to copy the file with its attributes and then removes the source file, effectively mimicking a move operation while preserving permissions.

Common Mistakes and Solutions

Mistake Solution
Overwriting files Use mv -n or mv -i
Losing file permissions Use mv --preserve=mode
Moving to inaccessible locations Check permissions with ls -l first
Accidentally moving directories Use mv -v to see what's being moved
Moving between filesystems Use rsync with --remove-source-files