To help us understand the reason behind various guidelines given later in the document, first let’s understand how the life cycle of a typical patch series for this project goes.

In the following sections, many techniques and conventions are listed to help your patches get reviewed effectively in such a life cycle.

As a preliminary step, you must first choose a starting point for your work. Typically this means choosing a branch, although technically speaking it is actually a particular commit (typically the HEAD, or tip, of the branch).

There are several important branches to be aware of. Namely, there are four integration branches as discussed in gitworkflows[7]:

The branches lower on the list are typically descendants of the ones that come before it. For example, maint is an "older" branch than master because master usually has patches (commits) on top of maint.

There are also "topic" branches, which contain work from other contributors. Topic branches are created by the Git maintainer (in their fork) to organize the current set of incoming contributions on the mailing list, and are itemized in the regular "What’s cooking in git.git" announcements. To find the tip of a topic branch, run git log --first-parent master..seen and look for the merge commit. The second parent of this commit is the tip of the topic branch.

There is one guiding principle for choosing the right starting point: in general, always base your work on the oldest integration branch that your change is relevant to (see "Merge upwards" in gitworkflows[7]). What this principle means is that for the vast majority of cases, the starting point for new work should be the latest HEAD commit of maint or master based on the following cases:

This also means that next or seen are inappropriate starting points for your work, if you want your work to have a realistic chance of graduating to master. They are simply not designed to be used as a base for new work; they are only there to make sure that topics in flight work well together. This is why both next and seen are frequently re-integrated with incoming patches on the mailing list and force-pushed to replace previous versions of themselves. A topic that is literally built on top of next cannot be merged to master without dragging in all the other topics in next, some of which may not be ready.

For example, if you are making tree-wide changes, while somebody else is also making their own tree-wide changes, your work may have severe overlap with the other person’s work. This situation may tempt you to use next as your starting point (because it would have the other person’s work included in it), but doing so would mean you’ll not only depend on the other person’s work, but all the other random things from other contributors that are already integrated into next. And as soon as next is updated with a new version, all of your work will need to be rebased anyway in order for them to be cleanly applied by the maintainer.

Under truly exceptional circumstances where you absolutely must depend on a select few topic branches that are already in next but not in master, you may want to create your own custom base-branch by forking master and merging the required topic branches into it. You could then work on top of this base-branch. But keep in mind that this base-branch would only be known privately to you. So when you are ready to send your patches to the list, be sure to communicate how you created it in your cover letter. This critical piece of information would allow others to recreate your base-branch on their end in order for them to try out your work.

Finally, note that some parts of the system have dedicated maintainers with their own separate source code repositories (see the section "Subsystems" below).

Unless your patch is really trivial, you should not be sending out a patch that was generated between your working tree and your commit head. Instead, always make a commit with complete commit message and generate a series of patches from your repository. It is a good discipline.

Give an explanation for the change(s) that is detailed enough so that people can judge if it is good thing to do, without reading the actual patch text to determine how well the code does what the explanation promises to do.

If your description starts to get too long, that’s a sign that you probably need to split up your commit to finer grained pieces. That being said, patches which plainly describe the things that help reviewers check the patch, and future maintainers understand the code, are the most beautiful patches. Descriptions that summarize the point in the subject well, and describe the motivation for the change, the approach taken by the change, and if relevant how this differs substantially from the prior version, are all good things to have.

Make sure that you have tests for the bug you are fixing. See t/README for guidance.

When adding a new feature, make sure that you have new tests to show the feature triggers the new behavior when it should, and to show the feature does not trigger when it shouldn’t. After any code change, make sure that the entire test suite passes. When fixing a bug, make sure you have new tests that break if somebody else breaks what you fixed by accident to avoid regression. Also, try merging your work to next and seen and make sure the tests still pass; topics by others that are still in flight may have unexpected interactions with what you are trying to do in your topic.

Pushing to a fork of https://github.com/git/git will use their CI integration to test your changes on Linux, Mac and Windows. See the GitHub CI section for details.

Do not forget to update the documentation to describe the updated behavior and make sure that the resulting documentation set formats well (try the Documentation/doc-diff script).

We currently have a liberal mixture of US and UK English norms for spelling and grammar, which is somewhat unfortunate. A huge patch that touches the files all over the place only to correct the inconsistency is not welcome, though. Potential clashes with other changes that can result from such a patch are not worth it. We prefer to gradually reconcile the inconsistencies in favor of US English, with small and easily digestible patches, as a side effect of doing some other real work in the vicinity (e.g. rewriting a paragraph for clarity, while turning en_UK spelling to en_US). Obvious typographical fixes are much more welcomed ("teh → "the"), preferably submitted as independent patches separate from other documentation changes.

Oh, another thing. We are picky about whitespaces. Make sure your changes do not trigger errors with the sample pre-commit hook shipped in templates/hooks--pre-commit. To help ensure this does not happen, run git diff --check on your changes before you commit.

The log message that explains your changes is just as important as the changes themselves. Your code may be clearly written with in-code comment to sufficiently explain how it works with the surrounding code, but those who need to fix or enhance your code in the future will need to know why your code does what it does, for a few reasons:

The goal of your log message is to convey the why behind your change to help future developers. The reviewers will also make sure that your proposed log message will serve this purpose well.

The first line of the commit message should be a short description (50 characters is the soft limit, see DISCUSSION in git-commit[1]), and should skip the full stop. It is also conventional in most cases to prefix the first line with "area: " where the area is a filename or identifier for the general area of the code being modified, e.g.

If in doubt which identifier to use, run git log --no-merges on the files you are modifying to see the current conventions.

The title sentence after the "area:" prefix omits the full stop at the end, and its first word is not capitalized (the omission of capitalization applies only to the word after the "area:" prefix of the title) unless there is a reason to capitalize it other than because it is the first word in the sentence. E.g. "doc: clarify…​", not "doc: Clarify…​", or "githooks.txt: improve…​", not "githooks.txt: Improve…​". But "refs: HEAD is also treated as a ref" is correct, as we spell HEAD in all caps even when it appears in the middle of a sentence.

The body should provide a meaningful commit message, which:

The problem statement that describes the status quo is written in the present tense. Write "The code does X when it is given input Y", instead of "The code used to do Y when given input X". You do not have to say "Currently"---the status quo in the problem statement is about the code without your change, by project convention.

Describe your changes in imperative mood, e.g. "make xyzzy do frotz" instead of "[This patch] makes xyzzy do frotz" or "[I] changed xyzzy to do frotz", as if you are giving orders to the codebase to change its behavior. Try to make sure your explanation can be understood without external resources. Instead of giving a URL to a mailing list archive, summarize the relevant points of the discussion.

There are a few reasons why you may want to refer to another commit in the "more stable" part of the history (i.e. on branches like maint, master, and next):

When you reference a commit on a more stable branch (like master, maint and next), use the format "abbreviated hash (subject, date)", like this:

The "Copy commit reference" command of gitk can be used to obtain this format (with the subject enclosed in a pair of double-quotes), or this invocation of git show:

or, on an older version of Git without support for --pretty=reference:

To improve tracking of who did what, we ask you to certify that you wrote the patch or have the right to pass it on under the same license as ours, by "signing off" your patch. Without sign-off, we cannot accept your patches.

If (and only if) you certify the below D-C-O:

you add a "Signed-off-by" trailer to your commit, that looks like this:

This line can be added by Git if you run the git-commit command with the -s option.

Notice that you can place your own Signed-off-by trailer when forwarding somebody else’s patch with the above rules for D-C-O. Indeed you are encouraged to do so. Do not forget to place an in-body "From: " line at the beginning to properly attribute the change to its true author (see (2) above).

This procedure originally came from the Linux kernel project, so our rule is quite similar to theirs, but what exactly it means to sign-off your patch differs from project to project, so it may be different from that of the project you are accustomed to.

Also notice that a real name is used in the Signed-off-by trailer. Please don’t hide your real name.

If you like, you can put extra tags at the end:

While you can also create your own trailer if the situation warrants it, we encourage you to instead use one of the common trailers in this project highlighted above.

Only capitalize the very first letter of tags, i.e. favor "Signed-off-by" over "Signed-Off-By" and "Acked-by:" over "Acked-By".

Git based diff tools generate unidiff which is the preferred format.

You do not have to be afraid to use -M option to git diff or git format-patch, if your patch involves file renames. The receiving end can handle them just fine.

Please make sure your patch does not add commented out debugging code, or include any extra files which do not relate to what your patch is trying to achieve. Make sure to review your patch after generating it, to ensure accuracy. Before sending out, please make sure it cleanly applies to the starting point you have chosen in the "Choose a starting point" section.

When revising changes made to your patches, it’s important to acknowledge the possibility of conflicts with other ongoing topics. To navigate these potential conflicts effectively, follow the recommended steps outlined below:

(Johannes Schindelin)

(Linus Torvalds)

(Daniel Barkalow)

See the MUA-SPECIFIC HINTS section of git-format-patch[1].

"|" in the *Summary* buffer can be used to pipe the current message to an external program, and this is a handy way to drive git am. However, if the message is MIME encoded, what is piped into the program is the representation you see in your *Article* buffer after unwrapping MIME. This is often not what you would want for two reasons. It tends to screw up non-ASCII characters (most notably in people’s names), and also whitespaces (fatal in patches). Running "C-u g" to display the message in raw form before using "|" to run the pipe can work this problem around.