# advcpmv: Progress Bars for GNU cp and mv

> advcpmv patches GNU Coreutils to add progress reporting to selected copy and move operations. It is useful for users who need feedback during long transfers, but its patch-based installation ties the build to a matching Coreutils release.

**jarun/advcpmv** — A patch for GNU Core Utilities cp, mv to add progress bars

- Repository: https://github.com/jarun/advcpmv
- Stars: 1,437 · Forks: 101
- Language: Shell
- License: not declared
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/jarun-advcpmv

## Why advcpmv patches GNU cp and mv

advcpmv addresses a narrow gap in GNU Coreutils: `cp` and `mv` do not show a progress bar during a transfer. The project modifies those commands rather than replacing them with a separate transfer application. According to the README, Advanced Copy was written by Florian Zwicke and released under the GPL. The repository preserves the project after its original website became unavailable, with an archived copy linked from the README.

The intended users are people running Unix-like systems who already use GNU `cp` and `mv`, understand shell administration, and want visual feedback during long-running operations. The feature is opt-in in the documented shell integrations, because `cpg -g` and `mvg -g` provide the progress-bar behavior, while ordinary calls to the system commands can remain unchanged.

This is not a general-purpose backup application. The repository does not document scheduling, verification, retries, exclusions, remote transfers, or directory synchronization. Its scope is deliberately limited to modifying the behavior of two familiar Coreutils programs.

## How the Coreutils patch adds transfer feedback

Based on the repository layout, advcpmv ships a set of patch files rather than prebuilt `cpg` and `mvg` executables. Each patch name includes an advcpmv version and a Coreutils version, such as `advcpmv-0.8-8.32.patch` and `advcpmv-0.9-9.11.patch`. The README says that `advcpmv-0.5-8.21.patch` was the author's final original patch and that later versions rebased that work on newer Coreutils releases.

The build process applies a selected patch to Coreutils and compiles the result. The generated files are named `advcp` and `advmv`. The documentation calls these Advanced Copy tools, with `-g` selecting progress output. The patch itself is the mechanism connecting progress reporting to the established `cp` and `mv` implementation, although the README does not describe its internal C functions or terminal rendering logic.

There is one documented feature conflict. Progress bars do not work with reflink, which the README identifies as available from version 9.0 onward. With `-g`, reflink is disabled; without the progress option, its behavior is left unchanged. This is an important trade-off for file systems and workflows that depend on reflink.

## Installing advcpmv with install.sh

The README lists `patch` and `gcc` as build dependencies. The Bash command downloads `install.sh`, creates the `advcpmv` directory, enters it, and runs the script. The script then downloads, patches, and compiles Coreutils according to the repository's installation flow.

```bash
curl https://raw.githubusercontent.com/jarun/advcpmv/master/install.sh --create-dirs -o ./advcpmv/install.sh && (cd advcpmv && sh install.sh)
```

The expected result is a patched build that produces `./advcpmv/advcp` and `./advcpmv/advmv`. The README also documents Fish syntax for the same installation process:

```fish
curl https://raw.githubusercontent.com/jarun/advcpmv/master/install.sh --create-dirs -o ./advcpmv/install.sh; and begin; cd advcpmv; and sh install.sh; end
```

Older versions can be selected through the version argument. The documented abbreviated form is:

```bash
... sh install.sh 0.8 8.32 ...
```

If the repository has already been cloned, the README says to pass the patch path as the only argument. The script infers both versions from the filename:

```bash
sh install.sh advcpmv-0.8-8.32.patch
```

The repository lists patches through Coreutils 9.11, but the README does not state which one the installer selects by default. That default should be checked in `install.sh` before a build.

## First use with cpg and mvg

The shortest documented workflow is to place the generated binaries in `$PATH` under the names `cpg` and `mvg`, then call them with `-g`. The commands below move the build outputs into `/usr/local/bin`.

```bash
sudo mv ./advcpmv/advcp /usr/local/bin/cpg
sudo mv ./advcpmv/advmv /usr/local/bin/mvg
```

Afterward, `cpg -g` replaces the familiar `cp` invocation with progress reporting, and `mvg -g` does the same for `mv`. The README does not give a concrete transfer command with file paths, so the supported first-use pattern is the binary names and option shown in its usage section.

For Bash or other POSIX-compatible shells, aliases can map the normal command names to the progress-enabled binaries:

```bash
echo -e 'alias cp=\x27/usr/local/bin/cpg -g\x27' >> ~/.bashrc
echo -e 'alias mv=\x27/usr/local/bin/mvg -g\x27' >> ~/.bashrc
```

The aliases affect interactive shell use and make progress reporting the default for those names. The README also documents `advcp` and `advmv` without renaming them, which is more suitable when a script or operator wants to keep GNU `cp` and `mv` as the default.

## Keeping cp and mv unchanged by default

advcpmv offers a shell-function approach that preserves ordinary command behavior. In the documented functions, an initial `-g` is consumed and passed to `/usr/local/bin/advcp` or `/usr/local/bin/advmv`; all other calls go directly to `command cp` or `command mv`. This design is useful for users who want progress reporting only when requested rather than changing the meaning of every interactive `cp` or `mv` call.

```bash
cp() {
	if [ "$1" = "-g" ]; then
		shift
		/usr/local/bin/advcp -g "$@"
	else
		command cp "$@"
	fi
}
```

```bash
mv() {
	if [ "$1" = "-g" ]; then
		shift
		/usr/local/bin/advmv -g "$@"
	else
		command mv "$@"
	fi
}
```

The README says these functions work in Bash, Zsh, Ksh, Dash, and other POSIX-compatible shells. Fish does not support this function syntax, so the Fish aliases are the documented alternative. The option check also only recognizes `-g` in the first argument position; the README does not describe argument parsing beyond that example.

## Version matching, reflink, and operational limits

The main operational constraint is version coupling. The repository provides separate patch files for different Coreutils versions, and the README requires matching a patch to the source it modifies. Advcpmv is therefore not simply a small wrapper that can be dropped beside every system `cp`. A patch built against one Coreutils release should not be assumed to apply cleanly to another.

Reflink is the clearest behavioral limitation. The README states that progress output and reflink do not work together from Coreutils 9.0 onward, causing reflink to be disabled when the progress bar is enabled. Users relying on reflink for copy-on-write behavior should treat `cpg -g` and `mvg -g` as incompatible with that requirement.

The upstream Coreutils team did not merge the patch because `mv` and `cp` were considered feature complete, according to the README. That leaves advcpmv as a downstream patch rather than a standard Coreutils feature. The README also does not document portability across distributions, terminal behavior, performance, file-system exceptions, or rollback after installation. Those points require direct evaluation rather than inference from the repository name.

## Comparing advcpmv with the system commands

The practical alternative is the unmodified GNU `cp` and `mv` supplied by the system. Their advantage is distribution ownership: they are already integrated with the operating system, do not require a local Coreutils patch, and avoid selecting a compatible patch file. They also preserve the standard behavior associated with the installed Coreutils version, including features not covered by advcpmv's documentation.

Advcpmv differs by adding a progress bar and status information to the patched commands. That difference matters when a transfer takes long enough that silence is inconvenient, especially in an interactive shell. The trade-off is maintenance and compatibility work: the user needs `patch`, `gcc`, a source build, and an appropriate patch.

The documented shell-function integration is more conservative than replacing `cp` and `mv` globally. It keeps the system commands as the default and routes only calls beginning with `-g` to Advanced Copy. However, aliases and functions are shell configuration, so their availability depends on how each terminal or session starts.

## Conclusion

Adopt advcpmv if you specifically need opt-in progress bars for GNU cp and mv and are comfortable compiling a patched Coreutils release. Do not adopt it if you need an upstream package, predictable version selection, or reflink with progress reporting. Before installing, verify that your chosen patch matches the Coreutils source version selected by install.sh and confirm that the documented alias behavior fits your shell workflow.

## FAQ

### How do I install advcpmv on Bash or Fish?

The README lists `patch` and `gcc` as dependencies. Its Bash and Fish commands download `install.sh`, create the `advcpmv` directory, and run the installer, which patches and compiles Coreutils.

### How do I enable progress bars for cp and mv?

Run the generated binaries as `cpg -g` and `mvg -g`. The README also documents aliases or shell functions that can route `cp` and `mv` calls with `-g` to those binaries while leaving ordinary calls unchanged.

### Does advcpmv support reflink when the progress bar is enabled?

No. The README states that reflink, introduced in Coreutils 9.0, does not work with the progress bar and is disabled when that option is used. Without progress reporting, reflink behavior is left unchanged.

### Can I select an older advcpmv and Coreutils version?

Yes. The README documents passing `0.8 8.32` to `install.sh`, or passing `advcpmv-0.8-8.32.patch` as its only argument so the versions are inferred from the filename.

## Sources

- [Issues](https://github.com/jarun/advcpmv/issues)
- [jarun/advcpmv on GitHub](https://github.com/jarun/advcpmv)
- [README](https://github.com/jarun/advcpmv/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jarun-advcpmv