Unix & Linux Stack Exchange is a question and answer site for users of Linux, FreeBSD and other Un*x-like operating systems. 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

What's the difference between patch -p0 and patch -p1?

Is there any difference at all?

share|improve this question
up vote 13 down vote accepted

The most common way to create a patch is to run the diff command or some version control's built-in diff-like command. Sometimes, you're just comparing two files, and you run diff like this:

diff -u version_by_alice.txt version_by_bob.txt >alice_to_bob.patch

Then you get a patch that contains changes for one file and doesn't contain a file name at all. When you apply that patch, you need to specify which file you want to apply it to:

patch <alice_to_bob.patch version2_by_alice.txt

Often, you're comparing two versions of a whole multi-file project contained in a directory. A typical invocation of diff looks like this:

diff -ru old_version new_version >some.patch

Then the patch contains file names, given in header lines like diff -ru old_version/dir/file new_version/dir/file. You need to tell patch to strip the prefix (old_version or new_version) from the file name. That's what -p1 means: strip one level of directory.

Sometimes, the header lines in the patch contain the file name directly with no lead-up. This is common with version control systems; for example cvs diff produces header lines that look like diff -r1.42 foo. Then there is no prefix to strip, so you must specify -p0.

In the special case when there are no subdirectories in the trees that you're comparing, no -p option is necessary: patch will discard all the directory part of the file names. But most of the time, you do need either -p0 or -p1, depending on how the patch was produced.

share|improve this answer

From the man:

-pnum or --strip=num Strip the smallest prefix containing num leading slashes from each file name found in the patch file. A sequence of one or more adjacent slashes is counted as a single slash. This controls how file names found in the patch file are treated, in case you keep your files in a different directory than the person who sent out the patch. For example, supposing the file name in the patch file was:


setting -p0 gives the entire file name unmodified, -p1 gives


without the leading slash, -p4 gives

share|improve this answer

I'll explain through examples and finish with a note.

Say we have a path with three slashes:


running a patch on it with the -p0 argument will take the path as it is, unmodified:


-p1 will remove the root slash (note it's just George now, without a slash from the left):


-p2 will remove George (and adjacent right slash):


-p3 will remove W (and adjacent right slash):



In most cases, people will use p0 from as it gives them the most accurate path to act upon --- from anywhere in the system; That's because, in many cases, you just copy the whole path from somewhere, and then work with it, and no p1 or any further shortenings are needed.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.