How to rename a directory in Linux: the mv command for files and folders

Short answer: to rename a directory in Linux, run mv old_name new_name. The same command renames a file, and mv file dir/ moves a file into a directory. One trap: if new_name is already an existing directory, mv puts old_name inside it instead of renaming it. Add -i to be asked before anything gets overwritten.

mv old_name new_name          # rename a directory (or a file), no -r needed
mv report.pdf archive/        # move a file into a directory
mv -i draft.txt final.txt     # ask before overwriting final.txt
mv -T site site-old           # rename only; never move site into an existing site-old

The outputs on this page come from Debian 12 with GNU coreutils 9.1 and bash 5.2.15, run in a scratch directory on 21 October 2026, including rename.ul from util-linux 2.38.1 and rsync 3.2.7. The Perl rename lines follow its man page, and the cross-filesystem behaviour follows the GNU coreutils manual; neither was run here. Ubuntu, Rocky Linux and AlmaLinux ship the same GNU mv.

mv cheat sheet

How do I rename a directory in Linux?

Give mv the current name and the new one. Unlike cp, it needs no -r for a directory, because nothing is copied: on the same filesystem, mv only changes the name in the parent directory. That is why renaming a directory with thousands of files is instant, and why owner, permissions and timestamps stay exactly as they were.

$ mv -v old_name new_name
renamed 'old_name' -> 'new_name'
$ ls -R new_name
new_name:
sub

new_name/sub:
a

Paths work too, so mv /srv/app/releases/v1 /srv/app/releases/v1-broken renames a directory without changing into its parent first. Quote names with spaces: mv My Folder new without quotes tries to move two things called My and Folder.

When the new name already exists as a directory

This is where renaming goes wrong. If the second name is an existing directory, mv does not replace it; it moves the first directory into it:

$ mkdir site site-old
$ mv -v site site-old
renamed 'site' -> 'site-old/site'

Run the same command a day later in a deploy script, after site-old already exists, and you get a nested site-old/site instead of a rename. -T (--no-target-directory) tells mv to treat the second name as the new name and nothing else. It replaces an empty directory and refuses a full one:

$ mv -Tv site2 empty
renamed 'site2' -> 'empty'
$ mv -T src dst
mv: cannot move 'src' to 'dst': Directory not empty

mv never merges two directories. To combine src into an existing dst, copy with rsync and remove the source afterwards, as shown further down.

Rename a file, and what happens to an existing one

mv notes.txt todo.txt renames a file. If todo.txt already exists, plain mv replaces it without a word, and the old content is gone. Three options protect it:

$ mv -i a.conf b.conf
mv: overwrite 'b.conf'? n
$ mv -nv a.conf b.conf          # -n: silently skip, b.conf untouched
$ mv -bv a.conf b.conf          # -b: overwrite, keep the old one as b.conf~
renamed 'a.conf' -> 'b.conf' (backup: 'b.conf~')

--backup=numbered keeps every old version instead of only the last one (d.~1~, d.~2~, and so on), and -S .bak changes the suffix of a simple backup from ~ to .bak. On a server, mv -b is a cheap safety net when you put a new config file in place of a working one.

Move files into a directory

When the last argument is an existing directory, mv moves everything before it into that directory and keeps the names. Write the directory with a trailing slash: if it does not exist (a typo), mv then stops instead of renaming your file to the typo:

$ mv -v *.log archive/
renamed 'a.log' -> 'archive/a.log'
renamed 'b.log' -> 'archive/b.log'
renamed 'c.log' -> 'archive/c.log'
$ mv -v x.txt nodir/
mv: cannot move 'x.txt' to 'nodir/': Not a directory

With more than two names, the last one must be a directory, otherwise mv answers target 'r': Not a directory. -t DIR names the target directory first, which is what find -exec ... + and xargs need, because they append the file names at the end. The find guide explains the + form:

# move logs older than 30 days, from anywhere below logs/, into old/
find logs -name '*.log' -mtime +30 -exec mv -v -t old/ {} +

# the same with xargs, safe for names with spaces
find logs -name '*.log' -mtime +30 -print0 | xargs -0 mv -t old/

That is also the fix for Argument list too long, which bash prints when a glob such as mv *.jpg photos/ expands to more names than the kernel accepts in one command line.

mv options: -i, -n, -f, -u, -v

If you combine -i, -f and -n, the last one wins: mv -f -i asks, mv -i -f does not. That matters because Rocky Linux and AlmaLinux alias mv to mv -i in root’s ~/.bashrc (Debian ships the same line commented out in /usr/share/base-files/dot.bashrc), so mv -f typed at that prompt still overwrites without asking. Scripts never see the alias: bash does not expand aliases in a non-interactive shell.

Rename many files at once

mv renames one thing at a time. For a batch, either loop over the files in bash and build each new name with parameter expansion, or use a rename tool. The loop works on every system with bash and needs nothing installed:

# .jpeg to .jpg
for f in *.jpeg; do mv -v -- "$f" "${f%.jpeg}.jpg"; done

# spaces to underscores
for f in *' '*; do mv -v -- "$f" "${f// /_}"; done

# upper case to lower case (bash 4 and later)
for f in *.TXT; do mv -v -- "$f" "${f,,}"; done

# add a prefix
for f in IMG_*.jpg; do mv -v -- "$f" "2026-10_$f"; done

renamed 'IMG_001.jpeg' -> 'IMG_001.jpg'
renamed 'IMG_002.jpeg' -> 'IMG_002.jpg'
renamed 'holiday photo.jpeg' -> 'holiday photo.jpg'

Three habits keep a loop safe. Run it once with echo mv in place of mv to see the commands first. Quote "$f" everywhere, so names with spaces survive. And put -- before the names, so a file called -draft is not read as an option. If no file matches, bash passes the pattern itself (*.png) to the loop; shopt -s nullglob turns that into an empty loop.

rename: two different tools with the same name

On Debian and Ubuntu, the rename package installs the Perl version, which takes a substitution expression. Rocky Linux, AlmaLinux and Fedora ship the util-linux version as rename, which replaces a plain string; Debian has that one as rename.ul. A command written for one fails on the other:

rename -n 's/\.jpeg$/.jpg/' *.jpeg    # -n: show what would happen
rename 's/\.jpeg$/.jpg/' *.jpeg

$ rename.ul -n -v .bak .log *.bak
`log1.bak' -> `log1.log'
`log2.bak' -> `log2.log'
$ rename.ul -v .old .bak *.old
`log1.old' -> `log1.bak'
`log2.old' -> `log2.bak'

The util-linux version replaces the first occurrence of the string anywhere in the name, not only at the end, so check with -n first. For anything more than a suffix swap, the bash loop is easier to read and to review.

Moving across filesystems: copy, then delete

Inside one filesystem, mv calls the rename() system call, and the data never moves. Between two filesystems (another disk, a separate partition, an NFS mount, /tmp on tmpfs), rename is impossible, and per the GNU coreutils manual mv falls back to copying the files and then removing the originals. That changes what you should expect:

• It takes as long as a copy, and the target filesystem needs room for everything before the source is freed.
• An interrupted move leaves two halves: the source is removed only after the copy, so a Ctrl+C or a dropped SSH session leaves a partial copy at the destination. Run long moves inside tmux or screen.
• Checking which filesystem a path is on: df -h /srv/data /mnt/backup; two different lines in the first column mean a copy, not a rename.

For a large move between disks or servers, rsync is the better tool, because it can resume where it stopped and only removes a source file once it is safely copied:

rsync -a --remove-source-files src/ dst/     # copy, deleting each file once it is copied
find src -type d -empty -delete              # rsync leaves the empty folders behind

In the test, rsync moved src/a and src/sub/b into dst/ and left src and src/sub as empty folders, which the second line removed.

mv vs cp vs rsync

The timestamp row is easy to check: a file moved with mv keeps its inode number and its modification time, while a plain cp of a file dated 1 January 2025 came out with the current time. For copies between servers, see transferring files to a VPS.

mv errors and what they mean

mv: cannot move: Permission denied

mv: cannot move 'rootdir/file' to 'mine/file': Permission denied
mv: cannot move 'rootdir/file' to 'rootdir/file2': Permission denied

A rename changes two directories, not the file: it removes the name from the old parent and adds it to the new one. You need write and execute permission on both parents, and a file’s own mode does not matter. The second line shows it: even renaming a file inside the same root-owned folder failed. Moving a directory to another parent also needs write permission on that directory itself, because its .. entry changes (per rename(2)). Directories with the sticky bit, such as /tmp, add a rule on top: only the file’s owner, the directory’s owner or root may rename or move it out. namei -l /path/to/file lists owner and mode of every directory on the way, and the chmod guide explains what write and execute mean on a directory.

Renaming directories on a live server

On a server, a rename is rarely just a rename: something else usually has the old path written down.

• Configs keep the old path. Rename /var/www/shop and nginx, PHP-FPM pools, systemd units and crontab lines that name it break at their next reload. Search before you rename: sudo grep -rl /var/www/shop /etc.
• Running processes do not notice. A program keeps the files it has open and its working directory through a rename, so it may seem fine until it restarts and looks for the old path.
• Switch releases with a symlink, not a rename. Point a current link at the live release and replace the link, so the web server never sees a half-finished directory. mv -T replaces it in one step, because rename() replaces the old name atomically:

ln -s releases/v2 current.new
mv -Tv current.new current
# renamed 'current.new' -> 'current'

Without -T, mv follows the existing current link to its directory and drops current.new inside the old release, which is exactly what it did in the test (renamed 'current.new' -> 'current/current.new'). Create the folders you move things into with mkdir -p, and before a big reorganisation on a VMHeaven VPS, take a snapshot in the panel: it is the undo that mv itself does not have.

Frequently asked