How do I move all files in a directory (including the hidden ones) to another directory?

For example, if I have a folder "Foo" with the files ".hidden" and "notHidden" inside, how do I move both files to a directory named "Bar"? The following does not work, as the ".hidden" file stays in "Foo".

mv Foo/* Bar/

Try it yourself.

mkdir Foo
mkdir Bar
touch Foo/.hidden
touch Foo/notHidden
mv Foo/* Bar/
  • Bah, I knew I should have refreshed the answers before typing mine up. Very helpful link.
    – Steven D
    Jan 24, 2011 at 19:48
  • Sadly, this question ended up here because I said on SO that it should move here or SU, so of course it moved here when there was a duplicate on SU already :) Jan 24, 2011 at 20:06
  • Personally, I think *nix specific questions and answers should be off-topic on SU. With the current rules we end up with tons of content collisions between the two - like this question.
    – Cory Klein
    May 12, 2014 at 17:27

12 Answers 12



mv Foo/*(DN) Bar/


setopt -s glob_dots
mv Foo/*(N) Bar/

(Leave out the (N) if you know the directory is not empty.)


shopt -s dotglob
mv Foo/* Bar/


If you know the directory is not empty:

mv Foo/* Bar/

Standard (POSIX) sh

for x in Foo/* Foo/.[!.]* Foo/..?*; do
  if [ -e "$x" ]; then mv -- "$x" Bar/; fi

If you're willing to let the mv command return an error status even though it succeeded, it's a lot simpler:

mv Foo/* Foo/.[!.]* Foo/..?* Bar/

GNU find and GNU mv

find Foo/ -mindepth 1 -maxdepth 1 -exec mv -t Bar/ -- {} +

Standard find

If you don't mind changing to the source directory:

cd Foo/ &&
find . -name . -o -exec sh -c 'mv -- "$@" "$0"' ../Bar/ {} + -type d -prune

Here's more detail about controlling whether dot files are matched in bash, ksh93 and zsh.


Set the dotglob option.

$ echo *
none zero
$ shopt -s dotglob
$ echo *
..two .one none zero

There's also the more flexible GLOBIGNORE variable, which you can set to a colon-separated list of wildcard patterns to ignore. If unset (the default setting), the shell behaves as if the value was empty if dotglob is set, and as if the value was .* if the option is unset. See Filename Expansion in the manual. The pervasive directories . and .. are always omitted, unless the . is matched explicitly by the pattern.

$ echo *
..two .one zero
$ echo .*
..two .one
$ echo .*
. .. ..two .one
$ echo .*
..two .one


Set the FIGNORE variable. If unset (the default setting), the shell behaves as if the value was .*. To ignore . and .., they must be matched explicitly (the manual in ksh 93s+ 2008-01-31 states that . and .. are always ignored, but this does not correctly describe the actual behavior).

$ echo *
none zero
$ FIGNORE='@(.|..)'
$ echo *
..two .one none zero
$ FIGNORE='n*'
$ echo *
. .. ..two .one zero

You can include dot files in a pattern by matching them explicitly.

$ unset FIGNORE
$ echo @(*|.[^.]*|..?*)
..two .one none zero

To have the expansion come out empty if the directory is empty, use the N pattern matching option: ~(N)@(*|.[^.]*|..?*) or ~(N:*|.[^.]*|..?*).


Set the dot_glob option.

% echo *
none zero
% setopt dot_glob
% echo *
..two .one none zero

. and .. are never matched, even if the pattern matches the leading . explicitly.

% echo .*
..two .one

You can include dot files in a specific pattern with the D glob qualifier.

% echo *(D)
..two .one none zero

Add the N glob qualifier to make the expansion come out empty in an empty directory: *(DN).

Note: you may get filename expansion results in different orders (e.g., none followed by .one followed by ..two) based on your settings of the LC_COLLATE, LC_ALL, and LANG variables.

  • 2
    Why nullglob? It would make more sense to abort the mv command (like fish, csh/tcsh, zsh (without (N)) do, or bash with failglob) than running a mv /Bar/ command which makes little sense. Feb 21, 2016 at 16:29
  • 1
    I'd say your GLOBIGNORE description is inaccurate and misleading. Setting GLOBIGNORE to a non-empty value turns on dotglob and makes that . and .. are never matched (like in other sensible shells like zsh, fish, pdksh and derivatives) even if you turn dotglob back off afterwards. (GLOBIGNORE=:; shopt -u dotglob; echo .* won't output . and ..). setting GLOBIGNORE to .:.. or . or : have the same effect. Feb 21, 2016 at 19:37
  • ksh93 always ignoring . and .. seems to have been broken in between ksh93k+ (where it worked) and ksh93m (where it no longer works). Note that it's bad in that ksh93 will take the value of FIGNORE from the environment, so a FIGNORE='!(..)' env var for instance can create havoc. Feb 21, 2016 at 21:05
  • Is there documentation somewhere on the (DN) option in zsh? can't find it.
    – Plumpie
    Jul 22, 2020 at 13:17
  • @Plumpie It's two glob qualifiers. There's a link to the documentation in my answer. Jul 22, 2020 at 13:45

shopt -s dotglob
mv Foo/* Bar/

From man bash

dotglob If set, bash includes filenames beginning with a '.' in the results of pathname expansion.

  • With the caveat that this command returns an error code if the directory was empty (even though the command actually performed as intended). Jan 24, 2011 at 20:28
  • 1
    @Gilles, the error will then be from mv complaining that that file called Foo/* doesn't exist. Interestingly, if Foo is searchable, but not readable, and there is a file called * in there, you'll get no error, that file will be moved, but not the other ones in the directory. bash has a failglob option so it behaves more like zsh, fish or csh/tcsh and abort the command with an error when a glob cannot be expanded instead of that bogus behaviour of leaving the glob as-is. Feb 22, 2016 at 10:01

A simple way to do this in bash is

mv {Foo/*,Foo/.*} Bar/

But this will also move directories.

If you want to move all files including hidden but don't want to move any directory you can use a for loop and test.

for i in $(ls -d {Foo/*,Foo/.*});do test -f $i && mv -v $i Bar/; done;

  • The easiest solution because it needs not to remember a second command : ) Thanks.
    – aderchox
    Oct 19, 2020 at 8:41
  • 1
    For even easier use, could also be mv foo/{*,.*} bar/ Nov 17, 2021 at 18:58
  • that's nice, thanks :) Nov 23, 2021 at 16:53

One way is to use find:

find Foo/ -type f -exec mv -t Bar/ {} \+

The -type f restricts the find command to finding files. You should investigate the -type, -maxdepth, and -mindepth options of find to customize your command to account for subdirectories. Find has a lengthy but very helpful manual page.


I find that this works well for bash and there's no need to change shell options

mv sourcedir/{*,.[^.]*} destdir/


So as G-man stated, my original answer is not posix compliant and is pretty much the same as ndemou’s answer above with one change, which is to use brace expansion to create lists of strings which are then acted on. This just means you don't need to cd into the source directory. Not that big a change really, but it is different.

example: let's say you have the following layout already.

 $ tree -a
├── destdir
└── sourcedir
    ├── ..d1
    ├── ..d2
    ├── ..double
    ├── file-1
    ├── file-2
    ├── .hidden-1
    ├── .hidden-2
    ├── ...t1
    └── ...t2

The original question only mentioned hidden files with a single period, but let's say there are some with two or more periods at the start of the name. You can just add in an additional expression into the braces. We can then execute

mv sourcedir/{*,.[!.]*,..?*} destdir/

This gets expanded to the following:

mv sourcedir/file-1 sourcedir/file-2 sourcedir/.hidden-1 sourcedir/.hidden-2 sourcedir/..d1 sourcedir/..d2 sourcedir/..double sourcedir/...t1 sourcedir/...t2 destdir/

You should now see all files located in destdir:

 $ tree -a
├── destdir
│   ├── ..d1
│   ├── ..d2
│   ├── ..double
│   ├── file-1
│   ├── file-2
│   ├── .hidden-1
│   ├── .hidden-2
│   ├── ...t1
│   └── ...t2
└── sourcedir

You can do some pretty cool things with braces in bash with even more additions in 4.x. Check out bash-hackers for some nifty examples.

  • 1
    This basically duplicates ndemou’s answer except you added curly braces (without explaining them).  But (1) your answer doesn’t match files whose names begin with .., and (2) to be POSIX compliant, you should use ! instead of ^; i.e., {*,.[!.]*}. Mar 6, 2019 at 4:23
  • @G-Man, sorry about that. So you are correct and my bad for not seeing ndemou's response. They are pretty much the same thing. 1. thank you for pointing out my version is not posix compliant. 2. I'm using the brace expansion to create lists of strings which the shell will then use to perform an action on. This also means I don't need to cd into the source directory to act on the files or write out the same file paths over and over to express the paths to all files. I'll update the example shortly to give any readers a better picture of what I'm talking about. Mar 7, 2019 at 17:22

Try the copy command cp:

$ cp -r myfolder/* destinationfolder

cp -r means copy recursive, so all folders and files will be copied.

You can use the remove command rm to remove a folder:

$ rm -r myfolder

See more: move all files from a directory to another one.

  • 2
    Not the best when you're moving a lot of large files, but I guess it would work.
    – Cory Klein
    May 12, 2014 at 17:25
  • Maybe if you use a dot instead of the star?
    – vincent
    Mar 21, 2019 at 18:23
  • 1
    Warning: this does not copy hidden files. The asterisk * does not include hidden files by default.
    – anonymous
    Dec 15, 2019 at 13:12

Rsync is another option:

rsync -axvP --remove-source-files sourcedirectory/ targetdirectory

This works because in rsync the trailing slash matters, sourcedirectory/ refers to the content of the directory, while sourcedirectory would refer to the directory itself.

The disadvantage of this method is that rsync will only cleanup the files after the move, not the directory. So you are left with an empty sourcedirectory tree. For workarounds for that, see:

Move files and delete directories with rsync?

So while this might not be optimal for move operations, it can be extremely useful for copy operations.


For minimal Linux distros, the following ought to work. First, perform a basic move all (which misses the hidden files). Then, move all the hidden files (including the . and .. which will not actually be moved).

mv /sourceDir/* /destinationDir 2> /dev/null
mv /sourceDir/.* /destinationDir 2> /dev/null

Notes: If there is no visible content, the first command will produce an error message. The second command will always produce an error saying it can't move . and ... As such, just pipe the errors into /dev/null (as shown).

If you need this as a one-liner, simply combine them with a semi-colon:

mv /sourceDir/* /destinationDir 2> /dev/null; mv /sourceDir/.* /destinationDir 2> /dev/null
  • this helped me 2> /dev/null Mar 25, 2020 at 19:43
  • when combined with this mv {Foo/*,Foo/.*} Bar/ 2> /dev/null produces a desired result. 2> /dev/null runs that command in the background, so to ignore pipe errors on . and .. Mar 25, 2020 at 19:43

Answer for bash/fish

Here's a way to do it using wildcards:

.[!.]* ..?* will match all hidden files except . and ..

.[!.]* ..?* * will match all files (hidden or not) except . and ..

And to answer the particular example of this question you need cd foo && mv .[!.]* ..?* * ../bar


.[!.]* matches file-names starting with one dot, followed by any character except the dot optionally followed by any string. This is close enough but it misses files starting with two dots like ..foo. To include such files we add ..?* which matches file-names starting with two dots, followed by any character, optionally followed by any string.


You can test these wildcards with the commands below. I've tried them successfully under bash and fish. They fail under sh, zsh, xonsh.

mkdir temp
cd temp
touch  a  .b  .bc  ..c  ..cd  ...d  ...de
ls .[!.]* ..?*
# you get this output:
          .b  .bc  ..c  ..cd  ...d  ...de
# cleanup
cd ..
rm -rf temp

You might also be able to find and grep with backquotes to select files for the move command. Pass those into mv.

I.e. For hidden files

find Foo -maxdepth 1 | egrep '^Foo/[.]' # Output: .hidden


mv `find Foo -maxdepth 1 | egrep '^Foo/[.]'` Bar # mv Foo/.hidden Bar

Moves only selected hidden files into Bar:

mv `find Foo -maxdepth 1 | egrep '^Foo/.'` Bar # mv Foo/.hidden Foo/notHidden Bar

Moves all files in Foo to Bar since the '.' in the egrep command acts as a wildcard without the square brackets.

The ^ character ensures the match starts from the beginning of the line.

Some details of egrep pattern matching can be found here.

Using maxdepth 1 stops find from going into subdirectories.


Inspired from this answer:

Without copying the files...

rsync -ax --link-dest=../Foo/ Foo/ Bar


  • --link-dest path must be absolute or relative to DESTINATION (Bar in the example)

  • You've to put / after SOURCE (Foo/ in the example), otherwise it will copy the SOURCE folder instead of contents of it.


Short answer:

This is the most reliable method. It can digest any number of files:

find folder2 -name '*.*' -exec mv {} folder \;

-exec runs any command, {} inserts the filename found, \; marks the end of the exec command.

Thanks to Karl Bielefeldt: https://stackoverflow.com/a/11942473/4845952

You must log in to answer this question.

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