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
    Commented 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 :) Commented 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
    Commented May 12, 2014 at 17:27

12 Answers 12


Quick answers first; see below for more in-depth discussion and documentation links for bash, ksh93 and zsh.


mv Foo/*(DN) Bar/


setopt glob_dots null_glob
mv Foo/* Bar/

Case and underscores are ignored in the option name. set -o can also be used like in Korn/POSIX-like shells and dotglob (DotGlob, DOT_GLOB...) is also supported for compatibility with the GNU shell (bash).


shopt -s dotglob nullglob
mv Foo/* Bar/


If you know the directory is not empty:

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

find Foo/. ! -name . -prune -exec sh -c 'mv -- "$@" "$0"' ../Bar/ {} +

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 no longer correctly describe the actual behavior; edit that was fixed since).

$ 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. Commented 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. Commented 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. Commented Feb 21, 2016 at 21:05
  • Is there documentation somewhere on the (DN) option in zsh? can't find it.
    – Plumpie
    Commented Jul 22, 2020 at 13:17
  • @Plumpie It's two glob qualifiers. There's a link to the documentation in my answer. Commented 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). Commented 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. Commented 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
    Commented Oct 19, 2020 at 8:41
  • 1
    For even easier use, could also be mv foo/{*,.*} bar/ Commented Nov 17, 2021 at 18:58
  • that's nice, thanks :) Commented 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.

  • 3
    That only moves the regular files in Foo/, not subdirectories and other files. Commented Jan 24, 2011 at 20:29

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., {*,.[!.]*}. Commented 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. Commented Mar 7, 2019 at 17:22

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.


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
    Commented May 12, 2014 at 17:25
  • Maybe if you use a dot instead of the star?
    – vincent
    Commented Mar 21, 2019 at 18:23
  • 1
    Warning: this does not copy hidden files. The asterisk * does not include hidden files by default.
    – anonymous
    Commented Dec 15, 2019 at 13:12

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 Commented 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 .. Commented 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 .