Generate a Safe Rename Script

About this tool

You already know what the files should be called — the risky part is writing the script that does it. Paste the old,new mapping and this tool emits the rename script for you, quoted correctly, ordered so nothing gets clobbered, and paired with an undo script. It runs entirely in your browser and never touches a file: the output is text you review, save, and run yourself.

Each line is one pair. Comma, tab, |, and -> all work, and auto-detect picks the one that fits every line. Blank lines and # comments are ignored, and a header row such as old,new is skipped.

Worked example — this mapping:

IMG_001.JPG,photo-001.jpg
IMG_002.JPG,photo-002.jpg

produces this rename script (with the undo option off, for brevity):

#!/usr/bin/env bash
# Rename script generated by mv-script-generator — 2 renames.
# Review this script before running it. Nothing moves until you run it.
set -euo pipefail

mv_safe() {
  local src=$1 dst=$2
  if [ ! -e "$src" ] && [ ! -L "$src" ]; then
    printf 'mv-script: missing source: %s\n' "$src" >&2
    exit 1
  fi
  if [ -e "$dst" ] || [ -L "$dst" ]; then
    printf 'mv-script: destination exists: %s\n' "$dst" >&2
    exit 1
  fi
  mkdir -p -- "$(dirname -- "$dst")"
  mv -- "$src" "$dst"
}

mv_safe 'IMG_001.JPG' 'photo-001.jpg'
mv_safe 'IMG_002.JPG' 'photo-002.jpg'

What the generator does that a hand-written loop usually doesn't

• Ordering. A chained mapping (a → b, b → c) is sorted so b → c runs first. Written in the order you typed it, a → b would destroy b before it was ever moved.
• Cycles. A straight swap (a → b, b → a) can't be ordered at all, so one side is staged through a .mvtmp1 temp name and finished at the end — and the undo script unwinds through the same temp name.
• Quoting. Every path is single-quoted with dialect-correct escaping ('\'' for POSIX, doubled '' for PowerShell) and passed after mv -- or via -LiteralPath, so spaces, apostrophes, $HOME, and leading dashes are all inert.
• Collision checks. Two lines renaming the same file, or two lines producing the same new name, are refused up front with both line numbers — before a script exists that could destroy something.
• Guards at run time. The emitted helper aborts on a missing source, and (unless you allow overwriting) on a destination that already exists.

Options

• Script dialect — bash writes set -euo pipefail plus an mv_safe helper; PowerShell writes $ErrorActionPreference = 'Stop' plus a Move-Safe helper that uses Rename-Item -LiteralPath for same-directory renames and Move-Item when the destination changes folder.
• Dry run — bash prints would move: old -> new for each pair; PowerShell passes the -WhatIf switch.
• Run in this directory — prepends a quoted cd -- / Set-Location -LiteralPath so your mapping can use bare filenames.
• Create missing destination directories — on by default, so a.txt -> 2026/01/a.txt works.
• Undo script — on by default; you get the reverse script under a second header in the same output.

Limits and edge cases

• Up to 1000 rename pairs per run.
• A pair whose old and new name are identical is skipped and counted in the header comment; if every pair is like that, you get an error instead of an empty script.
• Filenames containing control characters are refused — they cannot be written safely into a script.
• The tool assumes each old name exists and each new name does not. It cannot check that, so the emitted script checks at run time and stops on the first problem.
• Nothing is executed here. Read the script before you run it, and prefer a dry run on the real directory first.

FAQ