Super User is a question and answer site for computer enthusiasts and power users. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I've search the net for Linux's answer to something like Teracopy (Windows)... but could not find anything suitable.

The closest things i got are:

Can someone recommend me a simple file copy tool that can queue files for copy/move/delete? Preferably if I can drag and drop from Nautilus.

If something like this does not exist, can someone please tell me why? I the only person that needs something like this?

share|improve this question
If you could explain exactly what you want, it would be useful. I guess most linux users will not be familiar with "Teracopy". – Peltier Sep 8 '09 at 15:06
Is this because big copies and deletes take time and the GUI interface is unavailable/less useful while they are running? – dmckee Sep 8 '09 at 15:25
A partial explanation of this request can be found here:… – dmckee Sep 8 '09 at 17:40
Wait a minute, isn't MiniCopier available for Linux? It's a Java app. – Ryan Thompson Sep 13 '09 at 18:56
@Tobu Terracopy can queue and pause multiple copy job – Kokizzu Jul 16 '15 at 10:09

I just wrote this simple script, which I called 'cpw', to solve this problem.

You use it just like you would use cp... the only difference is that it builds an array of any cpw processes that are already running when it is started, and waits for them to finish before passing the commands on to cp. In this way, it behaves like a self-organizing queue.

You can keep adding background cpw jobs, but they won't step on each other. They'll execute one at a time.

I'm sure others can suggest improvements.


cpwpids=(`ps -ef | grep $USER | grep 'cpw' | grep -v grep | grep -v $$ | awk '{ print $2 }'`) #build an array of all cpw procs for this user that aren't this one.

cpwcnt=${#cpwpids[@]} # number of elemenets in the above array
cnt=$cpwcnt # counter to be decremented each pass
while [ $cnt -gt 0 ]
    for i in "${cpwpids[@]}" # check if each pid has died yet
        ps --pid $i >/dev/null
        if [ $? -gt 0 ]
            let "cnt -= 1"
    sleep 2
cp -v "$@" >> /tmp/cpw.log #log

Usage example:

$ cpw -R /src/tree /dest/tree &
share|improve this answer
Just a warning, I've tried this script and for a reason I haven't investigated further, it can hang indefinitely waiting for other scripts to finish. The more reliable way to achieve exclusivity in bash is to use flock -e . See for example here:… – px1mp Dec 11 '13 at 20:47

In my experience, doing a few copies simultaneously in Linux doesn't really reduce overall throughput. My measurement of throughput is based on rsync's -P argument. My particular case is separately copying a number of folders full of large files off of a USB hard drive at the same time.

So unless you're copying a lot of things at once, you should be fine.

share|improve this answer

Since the script given by Josh Arenberg might have some deadlocking issues (which I did not experience so far, but also have not investigated), I have written up something on my own. It should not have deadlocking problems. It also works for any shell command, not just cp.

Contents of ~/bin/q


#this waits for any PIDs to finish

    for pid in "$@"; do
        while kill -0 "$pid" 2&>1 >/dev/null; do
            sleep 0.5


#open PIDFILE and aquire lock
exec 9>>$PIDFILE
flock -w2 9 || { echo "ERROR: flock() failed." >&2; exit 1; }

#read previous instances PID from PIDFILE and write own PID to PIDFILE
echo $$>$PIDFILE

#release lock
flock -u 9

#wait for OLDPID
anywait $OLDPID

#do stuff

#afterwards: cleanup (if pidfile still contains own PID, truncate it)
flock -w2 9 || { echo "ERROR: flock() failed." >&2; exit 1; }
if [ $(<$PIDFILE) == $$ ]; then
truncate -s0 $PIDFILE
flock -u 9

It creates a chain of processes, each waiting for the previous one. If a process in the middle of the chain crashes while waiting (unlikely but not impossible), the chain is broken and both parts run in parallel. The same happens if one of the processes is killed.

Usage like this:


or even


Test e.g. by typing

q sleep 10 &
q echo blubb &

and finding that after 10 seconds blubb is printed.

share|improve this answer

Ultracopier is one you want, with Nemo plugin or Nautilus plugin.

share|improve this answer

I don't know of anything like this for Linux (though that's not to say that there isn't one somewhere). Linux software tends to get written by Linux users. Experienced Linux users may not think to create a tool like this, because if they notice any slowdown of copies during a GUI session they're likely to switch to a terminal and copy via commandline.

Here are some basic commandline copying utilities that are very fast and shouldn't affect your desktop environment:

  • cp ("cp foo /path/to/bar" will copy foo to bar)
  • mv ("mv foo /path/to/bar" will move (rename) foo to bar)
  • tar ("tar cf - foo | ( cd /path/to/archive/ ; tar xf - )" will recursively copy a directory)
  • rsync ("rsync -r foo /path/to/archive/" will recursively copy a directory)
share|improve this answer

Create a list of files and use SCP to perform the copy. The nice thing in linux is you can add to your text file using echo.

share|improve this answer

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .