Git 2.14.5
[git.git] / Documentation / config.txt
blob2271809d90a5855c40de64bf1952c58a48b0d386
1 CONFIGURATION FILE
2 ------------------
4 The Git configuration file contains a number of variables that affect
5 the Git commands' behavior. The `.git/config` file in each repository
6 is used to store the configuration for that repository, and
7 `$HOME/.gitconfig` is used to store a per-user configuration as
8 fallback values for the `.git/config` file. The file `/etc/gitconfig`
9 can be used to store a system-wide default configuration.
11 The configuration variables are used by both the Git plumbing
12 and the porcelains. The variables are divided into sections, wherein
13 the fully qualified variable name of the variable itself is the last
14 dot-separated segment and the section name is everything before the last
15 dot. The variable names are case-insensitive, allow only alphanumeric
16 characters and `-`, and must start with an alphabetic character.  Some
17 variables may appear multiple times; we say then that the variable is
18 multivalued.
20 Syntax
21 ~~~~~~
23 The syntax is fairly flexible and permissive; whitespaces are mostly
24 ignored.  The '#' and ';' characters begin comments to the end of line,
25 blank lines are ignored.
27 The file consists of sections and variables.  A section begins with
28 the name of the section in square brackets and continues until the next
29 section begins.  Section names are case-insensitive.  Only alphanumeric
30 characters, `-` and `.` are allowed in section names.  Each variable
31 must belong to some section, which means that there must be a section
32 header before the first setting of a variable.
34 Sections can be further divided into subsections.  To begin a subsection
35 put its name in double quotes, separated by space from the section name,
36 in the section header, like in the example below:
38 --------
39         [section "subsection"]
41 --------
43 Subsection names are case sensitive and can contain any characters except
44 newline (doublequote `"` and backslash can be included by escaping them
45 as `\"` and `\\`, respectively).  Section headers cannot span multiple
46 lines.  Variables may belong directly to a section or to a given subsection.
47 You can have `[section]` if you have `[section "subsection"]`, but you
48 don't need to.
50 There is also a deprecated `[section.subsection]` syntax. With this
51 syntax, the subsection name is converted to lower-case and is also
52 compared case sensitively. These subsection names follow the same
53 restrictions as section names.
55 All the other lines (and the remainder of the line after the section
56 header) are recognized as setting variables, in the form
57 'name = value' (or just 'name', which is a short-hand to say that
58 the variable is the boolean "true").
59 The variable names are case-insensitive, allow only alphanumeric characters
60 and `-`, and must start with an alphabetic character.
62 A line that defines a value can be continued to the next line by
63 ending it with a `\`; the backquote and the end-of-line are
64 stripped.  Leading whitespaces after 'name =', the remainder of the
65 line after the first comment character '#' or ';', and trailing
66 whitespaces of the line are discarded unless they are enclosed in
67 double quotes.  Internal whitespaces within the value are retained
68 verbatim.
70 Inside double quotes, double quote `"` and backslash `\` characters
71 must be escaped: use `\"` for `"` and `\\` for `\`.
73 The following escape sequences (beside `\"` and `\\`) are recognized:
74 `\n` for newline character (NL), `\t` for horizontal tabulation (HT, TAB)
75 and `\b` for backspace (BS).  Other char escape sequences (including octal
76 escape sequences) are invalid.
79 Includes
80 ~~~~~~~~
82 The `include` and `includeIf` sections allow you to include config
83 directives from another source. These sections behave identically to
84 each other with the exception that `includeIf` sections may be ignored
85 if their condition does not evaluate to true; see "Conditional includes"
86 below.
88 You can include a config file from another by setting the special
89 `include.path` (or `includeIf.*.path`) variable to the name of the file
90 to be included. The variable takes a pathname as its value, and is
91 subject to tilde expansion. These variables can be given multiple times.
93 The contents of the included file are inserted immediately, as if they
94 had been found at the location of the include directive. If the value of the
95 variable is a relative path, the path is considered to
96 be relative to the configuration file in which the include directive
97 was found.  See below for examples.
99 Conditional includes
100 ~~~~~~~~~~~~~~~~~~~~
102 You can include a config file from another conditionally by setting a
103 `includeIf.<condition>.path` variable to the name of the file to be
104 included.
106 The condition starts with a keyword followed by a colon and some data
107 whose format and meaning depends on the keyword. Supported keywords
108 are:
110 `gitdir`::
112         The data that follows the keyword `gitdir:` is used as a glob
113         pattern. If the location of the .git directory matches the
114         pattern, the include condition is met.
116 The .git location may be auto-discovered, or come from `$GIT_DIR`
117 environment variable. If the repository is auto discovered via a .git
118 file (e.g. from submodules, or a linked worktree), the .git location
119 would be the final location where the .git directory is, not where the
120 .git file is.
122 The pattern can contain standard globbing wildcards and two additional
123 ones, `**/` and `/**`, that can match multiple path components. Please
124 refer to linkgit:gitignore[5] for details. For convenience:
126  * If the pattern starts with `~/`, `~` will be substituted with the
127    content of the environment variable `HOME`.
129  * If the pattern starts with `./`, it is replaced with the directory
130    containing the current config file.
132  * If the pattern does not start with either `~/`, `./` or `/`, `**/`
133    will be automatically prepended. For example, the pattern `foo/bar`
134    becomes `**/foo/bar` and would match `/any/path/to/foo/bar`.
136  * If the pattern ends with `/`, `**` will be automatically added. For
137    example, the pattern `foo/` becomes `foo/**`. In other words, it
138    matches "foo" and everything inside, recursively.
140 `gitdir/i`::
141         This is the same as `gitdir` except that matching is done
142         case-insensitively (e.g. on case-insensitive file sytems)
144 A few more notes on matching via `gitdir` and `gitdir/i`:
146  * Symlinks in `$GIT_DIR` are not resolved before matching.
148  * Both the symlink & realpath versions of paths will be matched
149    outside of `$GIT_DIR`. E.g. if ~/git is a symlink to
150    /mnt/storage/git, both `gitdir:~/git` and `gitdir:/mnt/storage/git`
151    will match.
153 This was not the case in the initial release of this feature in
154 v2.13.0, which only matched the realpath version. Configuration that
155 wants to be compatible with the initial release of this feature needs
156 to either specify only the realpath version, or both versions.
158  * Note that "../" is not special and will match literally, which is
159    unlikely what you want.
161 Example
162 ~~~~~~~
164         # Core variables
165         [core]
166                 ; Don't trust file modes
167                 filemode = false
169         # Our diff algorithm
170         [diff]
171                 external = /usr/local/bin/diff-wrapper
172                 renames = true
174         [branch "devel"]
175                 remote = origin
176                 merge = refs/heads/devel
178         # Proxy settings
179         [core]
180                 gitProxy="ssh" for "kernel.org"
181                 gitProxy=default-proxy ; for the rest
183         [include]
184                 path = /path/to/foo.inc ; include by absolute path
185                 path = foo.inc ; find "foo.inc" relative to the current file
186                 path = ~/foo.inc ; find "foo.inc" in your `$HOME` directory
188         ; include if $GIT_DIR is /path/to/foo/.git
189         [includeIf "gitdir:/path/to/foo/.git"]
190                 path = /path/to/foo.inc
192         ; include for all repositories inside /path/to/group
193         [includeIf "gitdir:/path/to/group/"]
194                 path = /path/to/foo.inc
196         ; include for all repositories inside $HOME/to/group
197         [includeIf "gitdir:~/to/group/"]
198                 path = /path/to/foo.inc
200         ; relative paths are always relative to the including
201         ; file (if the condition is true); their location is not
202         ; affected by the condition
203         [includeIf "gitdir:/path/to/group/"]
204                 path = foo.inc
206 Values
207 ~~~~~~
209 Values of many variables are treated as a simple string, but there
210 are variables that take values of specific types and there are rules
211 as to how to spell them.
213 boolean::
215        When a variable is said to take a boolean value, many
216        synonyms are accepted for 'true' and 'false'; these are all
217        case-insensitive.
219         true;; Boolean true literals are `yes`, `on`, `true`,
220                 and `1`.  Also, a variable defined without `= <value>`
221                 is taken as true.
223         false;; Boolean false literals are `no`, `off`, `false`,
224                 `0` and the empty string.
226 When converting value to the canonical form using `--bool` type
227 specifier, 'git config' will ensure that the output is "true" or
228 "false" (spelled in lowercase).
230 integer::
231        The value for many variables that specify various sizes can
232        be suffixed with `k`, `M`,... to mean "scale the number by
233        1024", "by 1024x1024", etc.
235 color::
236        The value for a variable that takes a color is a list of
237        colors (at most two, one for foreground and one for background)
238        and attributes (as many as you want), separated by spaces.
240 The basic colors accepted are `normal`, `black`, `red`, `green`, `yellow`,
241 `blue`, `magenta`, `cyan` and `white`.  The first color given is the
242 foreground; the second is the background.
244 Colors may also be given as numbers between 0 and 255; these use ANSI
245 256-color mode (but note that not all terminals may support this).  If
246 your terminal supports it, you may also specify 24-bit RGB values as
247 hex, like `#ff0ab3`.
249 The accepted attributes are `bold`, `dim`, `ul`, `blink`, `reverse`,
250 `italic`, and `strike` (for crossed-out or "strikethrough" letters).
251 The position of any attributes with respect to the colors
252 (before, after, or in between), doesn't matter. Specific attributes may
253 be turned off by prefixing them with `no` or `no-` (e.g., `noreverse`,
254 `no-ul`, etc).
256 An empty color string produces no color effect at all. This can be used
257 to avoid coloring specific elements without disabling color entirely.
259 For git's pre-defined color slots, the attributes are meant to be reset
260 at the beginning of each item in the colored output. So setting
261 `color.decorate.branch` to `black` will paint that branch name in a
262 plain `black`, even if the previous thing on the same output line (e.g.
263 opening parenthesis before the list of branch names in `log --decorate`
264 output) is set to be painted with `bold` or some other attribute.
265 However, custom log formats may do more complicated and layered
266 coloring, and the negated forms may be useful there.
268 pathname::
269         A variable that takes a pathname value can be given a
270         string that begins with "`~/`" or "`~user/`", and the usual
271         tilde expansion happens to such a string: `~/`
272         is expanded to the value of `$HOME`, and `~user/` to the
273         specified user's home directory.
276 Variables
277 ~~~~~~~~~
279 Note that this list is non-comprehensive and not necessarily complete.
280 For command-specific variables, you will find a more detailed description
281 in the appropriate manual page.
283 Other git-related tools may and do use their own variables.  When
284 inventing new variables for use in your own tool, make sure their
285 names do not conflict with those that are used by Git itself and
286 other popular tools, and describe them in your documentation.
289 advice.*::
290         These variables control various optional help messages designed to
291         aid new users. All 'advice.*' variables default to 'true', and you
292         can tell Git that you do not need help by setting these to 'false':
295         pushUpdateRejected::
296                 Set this variable to 'false' if you want to disable
297                 'pushNonFFCurrent',
298                 'pushNonFFMatching', 'pushAlreadyExists',
299                 'pushFetchFirst', and 'pushNeedsForce'
300                 simultaneously.
301         pushNonFFCurrent::
302                 Advice shown when linkgit:git-push[1] fails due to a
303                 non-fast-forward update to the current branch.
304         pushNonFFMatching::
305                 Advice shown when you ran linkgit:git-push[1] and pushed
306                 'matching refs' explicitly (i.e. you used ':', or
307                 specified a refspec that isn't your current branch) and
308                 it resulted in a non-fast-forward error.
309         pushAlreadyExists::
310                 Shown when linkgit:git-push[1] rejects an update that
311                 does not qualify for fast-forwarding (e.g., a tag.)
312         pushFetchFirst::
313                 Shown when linkgit:git-push[1] rejects an update that
314                 tries to overwrite a remote ref that points at an
315                 object we do not have.
316         pushNeedsForce::
317                 Shown when linkgit:git-push[1] rejects an update that
318                 tries to overwrite a remote ref that points at an
319                 object that is not a commit-ish, or make the remote
320                 ref point at an object that is not a commit-ish.
321         statusHints::
322                 Show directions on how to proceed from the current
323                 state in the output of linkgit:git-status[1], in
324                 the template shown when writing commit messages in
325                 linkgit:git-commit[1], and in the help message shown
326                 by linkgit:git-checkout[1] when switching branch.
327         statusUoption::
328                 Advise to consider using the `-u` option to linkgit:git-status[1]
329                 when the command takes more than 2 seconds to enumerate untracked
330                 files.
331         commitBeforeMerge::
332                 Advice shown when linkgit:git-merge[1] refuses to
333                 merge to avoid overwriting local changes.
334         resolveConflict::
335                 Advice shown by various commands when conflicts
336                 prevent the operation from being performed.
337         implicitIdentity::
338                 Advice on how to set your identity configuration when
339                 your information is guessed from the system username and
340                 domain name.
341         detachedHead::
342                 Advice shown when you used linkgit:git-checkout[1] to
343                 move to the detach HEAD state, to instruct how to create
344                 a local branch after the fact.
345         amWorkDir::
346                 Advice that shows the location of the patch file when
347                 linkgit:git-am[1] fails to apply it.
348         rmHints::
349                 In case of failure in the output of linkgit:git-rm[1],
350                 show directions on how to proceed from the current state.
351         addEmbeddedRepo::
352                 Advice on what to do when you've accidentally added one
353                 git repo inside of another.
356 core.fileMode::
357         Tells Git if the executable bit of files in the working tree
358         is to be honored.
360 Some filesystems lose the executable bit when a file that is
361 marked as executable is checked out, or checks out a
362 non-executable file with executable bit on.
363 linkgit:git-clone[1] or linkgit:git-init[1] probe the filesystem
364 to see if it handles the executable bit correctly
365 and this variable is automatically set as necessary.
367 A repository, however, may be on a filesystem that handles
368 the filemode correctly, and this variable is set to 'true'
369 when created, but later may be made accessible from another
370 environment that loses the filemode (e.g. exporting ext4 via
371 CIFS mount, visiting a Cygwin created repository with
372 Git for Windows or Eclipse).
373 In such a case it may be necessary to set this variable to 'false'.
374 See linkgit:git-update-index[1].
376 The default is true (when core.filemode is not specified in the config file).
378 core.hideDotFiles::
379         (Windows-only) If true, mark newly-created directories and files whose
380         name starts with a dot as hidden.  If 'dotGitOnly', only the `.git/`
381         directory is hidden, but no other files starting with a dot.  The
382         default mode is 'dotGitOnly'.
384 core.ignoreCase::
385         If true, this option enables various workarounds to enable
386         Git to work better on filesystems that are not case sensitive,
387         like FAT. For example, if a directory listing finds
388         "makefile" when Git expects "Makefile", Git will assume
389         it is really the same file, and continue to remember it as
390         "Makefile".
392 The default is false, except linkgit:git-clone[1] or linkgit:git-init[1]
393 will probe and set core.ignoreCase true if appropriate when the repository
394 is created.
396 core.precomposeUnicode::
397         This option is only used by Mac OS implementation of Git.
398         When core.precomposeUnicode=true, Git reverts the unicode decomposition
399         of filenames done by Mac OS. This is useful when sharing a repository
400         between Mac OS and Linux or Windows.
401         (Git for Windows 1.7.10 or higher is needed, or Git under cygwin 1.7).
402         When false, file names are handled fully transparent by Git,
403         which is backward compatible with older versions of Git.
405 core.protectHFS::
406         If set to true, do not allow checkout of paths that would
407         be considered equivalent to `.git` on an HFS+ filesystem.
408         Defaults to `true` on Mac OS, and `false` elsewhere.
410 core.protectNTFS::
411         If set to true, do not allow checkout of paths that would
412         cause problems with the NTFS filesystem, e.g. conflict with
413         8.3 "short" names.
414         Defaults to `true` on Windows, and `false` elsewhere.
416 core.trustctime::
417         If false, the ctime differences between the index and the
418         working tree are ignored; useful when the inode change time
419         is regularly modified by something outside Git (file system
420         crawlers and some backup systems).
421         See linkgit:git-update-index[1]. True by default.
423 core.splitIndex::
424         If true, the split-index feature of the index will be used.
425         See linkgit:git-update-index[1]. False by default.
427 core.untrackedCache::
428         Determines what to do about the untracked cache feature of the
429         index. It will be kept, if this variable is unset or set to
430         `keep`. It will automatically be added if set to `true`. And
431         it will automatically be removed, if set to `false`. Before
432         setting it to `true`, you should check that mtime is working
433         properly on your system.
434         See linkgit:git-update-index[1]. `keep` by default.
436 core.checkStat::
437         Determines which stat fields to match between the index
438         and work tree. The user can set this to 'default' or
439         'minimal'. Default (or explicitly 'default'), is to check
440         all fields, including the sub-second part of mtime and ctime.
442 core.quotePath::
443         Commands that output paths (e.g. 'ls-files', 'diff'), will
444         quote "unusual" characters in the pathname by enclosing the
445         pathname in double-quotes and escaping those characters with
446         backslashes in the same way C escapes control characters (e.g.
447         `\t` for TAB, `\n` for LF, `\\` for backslash) or bytes with
448         values larger than 0x80 (e.g. octal `\302\265` for "micro" in
449         UTF-8).  If this variable is set to false, bytes higher than
450         0x80 are not considered "unusual" any more. Double-quotes,
451         backslash and control characters are always escaped regardless
452         of the setting of this variable.  A simple space character is
453         not considered "unusual".  Many commands can output pathnames
454         completely verbatim using the `-z` option. The default value
455         is true.
457 core.eol::
458         Sets the line ending type to use in the working directory for
459         files that have the `text` property set when core.autocrlf is false.
460         Alternatives are 'lf', 'crlf' and 'native', which uses the platform's
461         native line ending.  The default value is `native`.  See
462         linkgit:gitattributes[5] for more information on end-of-line
463         conversion.
465 core.safecrlf::
466         If true, makes Git check if converting `CRLF` is reversible when
467         end-of-line conversion is active.  Git will verify if a command
468         modifies a file in the work tree either directly or indirectly.
469         For example, committing a file followed by checking out the
470         same file should yield the original file in the work tree.  If
471         this is not the case for the current setting of
472         `core.autocrlf`, Git will reject the file.  The variable can
473         be set to "warn", in which case Git will only warn about an
474         irreversible conversion but continue the operation.
476 CRLF conversion bears a slight chance of corrupting data.
477 When it is enabled, Git will convert CRLF to LF during commit and LF to
478 CRLF during checkout.  A file that contains a mixture of LF and
479 CRLF before the commit cannot be recreated by Git.  For text
480 files this is the right thing to do: it corrects line endings
481 such that we have only LF line endings in the repository.
482 But for binary files that are accidentally classified as text the
483 conversion can corrupt data.
485 If you recognize such corruption early you can easily fix it by
486 setting the conversion type explicitly in .gitattributes.  Right
487 after committing you still have the original file in your work
488 tree and this file is not yet corrupted.  You can explicitly tell
489 Git that this file is binary and Git will handle the file
490 appropriately.
492 Unfortunately, the desired effect of cleaning up text files with
493 mixed line endings and the undesired effect of corrupting binary
494 files cannot be distinguished.  In both cases CRLFs are removed
495 in an irreversible way.  For text files this is the right thing
496 to do because CRLFs are line endings, while for binary files
497 converting CRLFs corrupts data.
499 Note, this safety check does not mean that a checkout will generate a
500 file identical to the original file for a different setting of
501 `core.eol` and `core.autocrlf`, but only for the current one.  For
502 example, a text file with `LF` would be accepted with `core.eol=lf`
503 and could later be checked out with `core.eol=crlf`, in which case the
504 resulting file would contain `CRLF`, although the original file
505 contained `LF`.  However, in both work trees the line endings would be
506 consistent, that is either all `LF` or all `CRLF`, but never mixed.  A
507 file with mixed line endings would be reported by the `core.safecrlf`
508 mechanism.
510 core.autocrlf::
511         Setting this variable to "true" is the same as setting
512         the `text` attribute to "auto" on all files and core.eol to "crlf".
513         Set to true if you want to have `CRLF` line endings in your
514         working directory and the repository has LF line endings.
515         This variable can be set to 'input',
516         in which case no output conversion is performed.
518 core.symlinks::
519         If false, symbolic links are checked out as small plain files that
520         contain the link text. linkgit:git-update-index[1] and
521         linkgit:git-add[1] will not change the recorded type to regular
522         file. Useful on filesystems like FAT that do not support
523         symbolic links.
525 The default is true, except linkgit:git-clone[1] or linkgit:git-init[1]
526 will probe and set core.symlinks false if appropriate when the repository
527 is created.
529 core.gitProxy::
530         A "proxy command" to execute (as 'command host port') instead
531         of establishing direct connection to the remote server when
532         using the Git protocol for fetching. If the variable value is
533         in the "COMMAND for DOMAIN" format, the command is applied only
534         on hostnames ending with the specified domain string. This variable
535         may be set multiple times and is matched in the given order;
536         the first match wins.
538 Can be overridden by the `GIT_PROXY_COMMAND` environment variable
539 (which always applies universally, without the special "for"
540 handling).
542 The special string `none` can be used as the proxy command to
543 specify that no proxy be used for a given domain pattern.
544 This is useful for excluding servers inside a firewall from
545 proxy use, while defaulting to a common proxy for external domains.
547 core.sshCommand::
548         If this variable is set, `git fetch` and `git push` will
549         use the specified command instead of `ssh` when they need to
550         connect to a remote system. The command is in the same form as
551         the `GIT_SSH_COMMAND` environment variable and is overridden
552         when the environment variable is set.
554 core.ignoreStat::
555         If true, Git will avoid using lstat() calls to detect if files have
556         changed by setting the "assume-unchanged" bit for those tracked files
557         which it has updated identically in both the index and working tree.
559 When files are modified outside of Git, the user will need to stage
560 the modified files explicitly (e.g. see 'Examples' section in
561 linkgit:git-update-index[1]).
562 Git will not normally detect changes to those files.
564 This is useful on systems where lstat() calls are very slow, such as
565 CIFS/Microsoft Windows.
567 False by default.
569 core.preferSymlinkRefs::
570         Instead of the default "symref" format for HEAD
571         and other symbolic reference files, use symbolic links.
572         This is sometimes needed to work with old scripts that
573         expect HEAD to be a symbolic link.
575 core.bare::
576         If true this repository is assumed to be 'bare' and has no
577         working directory associated with it.  If this is the case a
578         number of commands that require a working directory will be
579         disabled, such as linkgit:git-add[1] or linkgit:git-merge[1].
581 This setting is automatically guessed by linkgit:git-clone[1] or
582 linkgit:git-init[1] when the repository was created.  By default a
583 repository that ends in "/.git" is assumed to be not bare (bare =
584 false), while all other repositories are assumed to be bare (bare
585 = true).
587 core.worktree::
588         Set the path to the root of the working tree.
589         If `GIT_COMMON_DIR` environment variable is set, core.worktree
590         is ignored and not used for determining the root of working tree.
591         This can be overridden by the `GIT_WORK_TREE` environment
592         variable and the `--work-tree` command-line option.
593         The value can be an absolute path or relative to the path to
594         the .git directory, which is either specified by --git-dir
595         or GIT_DIR, or automatically discovered.
596         If --git-dir or GIT_DIR is specified but none of
597         --work-tree, GIT_WORK_TREE and core.worktree is specified,
598         the current working directory is regarded as the top level
599         of your working tree.
601 Note that this variable is honored even when set in a configuration
602 file in a ".git" subdirectory of a directory and its value differs
603 from the latter directory (e.g. "/path/to/.git/config" has
604 core.worktree set to "/different/path"), which is most likely a
605 misconfiguration.  Running Git commands in the "/path/to" directory will
606 still use "/different/path" as the root of the work tree and can cause
607 confusion unless you know what you are doing (e.g. you are creating a
608 read-only snapshot of the same index to a location different from the
609 repository's usual working tree).
611 core.logAllRefUpdates::
612         Enable the reflog. Updates to a ref <ref> is logged to the file
613         "`$GIT_DIR/logs/<ref>`", by appending the new and old
614         SHA-1, the date/time and the reason of the update, but
615         only when the file exists.  If this configuration
616         variable is set to `true`, missing "`$GIT_DIR/logs/<ref>`"
617         file is automatically created for branch heads (i.e. under
618         `refs/heads/`), remote refs (i.e. under `refs/remotes/`),
619         note refs (i.e. under `refs/notes/`), and the symbolic ref `HEAD`.
620         If it is set to `always`, then a missing reflog is automatically
621         created for any ref under `refs/`.
623 This information can be used to determine what commit
624 was the tip of a branch "2 days ago".
626 This value is true by default in a repository that has
627 a working directory associated with it, and false by
628 default in a bare repository.
630 core.repositoryFormatVersion::
631         Internal variable identifying the repository format and layout
632         version.
634 core.sharedRepository::
635         When 'group' (or 'true'), the repository is made shareable between
636         several users in a group (making sure all the files and objects are
637         group-writable). When 'all' (or 'world' or 'everybody'), the
638         repository will be readable by all users, additionally to being
639         group-shareable. When 'umask' (or 'false'), Git will use permissions
640         reported by umask(2). When '0xxx', where '0xxx' is an octal number,
641         files in the repository will have this mode value. '0xxx' will override
642         user's umask value (whereas the other options will only override
643         requested parts of the user's umask value). Examples: '0660' will make
644         the repo read/write-able for the owner and group, but inaccessible to
645         others (equivalent to 'group' unless umask is e.g. '0022'). '0640' is a
646         repository that is group-readable but not group-writable.
647         See linkgit:git-init[1]. False by default.
649 core.warnAmbiguousRefs::
650         If true, Git will warn you if the ref name you passed it is ambiguous
651         and might match multiple refs in the repository. True by default.
653 core.compression::
654         An integer -1..9, indicating a default compression level.
655         -1 is the zlib default. 0 means no compression,
656         and 1..9 are various speed/size tradeoffs, 9 being slowest.
657         If set, this provides a default to other compression variables,
658         such as `core.looseCompression` and `pack.compression`.
660 core.looseCompression::
661         An integer -1..9, indicating the compression level for objects that
662         are not in a pack file. -1 is the zlib default. 0 means no
663         compression, and 1..9 are various speed/size tradeoffs, 9 being
664         slowest.  If not set,  defaults to core.compression.  If that is
665         not set,  defaults to 1 (best speed).
667 core.packedGitWindowSize::
668         Number of bytes of a pack file to map into memory in a
669         single mapping operation.  Larger window sizes may allow
670         your system to process a smaller number of large pack files
671         more quickly.  Smaller window sizes will negatively affect
672         performance due to increased calls to the operating system's
673         memory manager, but may improve performance when accessing
674         a large number of large pack files.
676 Default is 1 MiB if NO_MMAP was set at compile time, otherwise 32
677 MiB on 32 bit platforms and 1 GiB on 64 bit platforms.  This should
678 be reasonable for all users/operating systems.  You probably do
679 not need to adjust this value.
681 Common unit suffixes of 'k', 'm', or 'g' are supported.
683 core.packedGitLimit::
684         Maximum number of bytes to map simultaneously into memory
685         from pack files.  If Git needs to access more than this many
686         bytes at once to complete an operation it will unmap existing
687         regions to reclaim virtual address space within the process.
689 Default is 256 MiB on 32 bit platforms and 32 TiB (effectively
690 unlimited) on 64 bit platforms.
691 This should be reasonable for all users/operating systems, except on
692 the largest projects.  You probably do not need to adjust this value.
694 Common unit suffixes of 'k', 'm', or 'g' are supported.
696 core.deltaBaseCacheLimit::
697         Maximum number of bytes to reserve for caching base objects
698         that may be referenced by multiple deltified objects.  By storing the
699         entire decompressed base objects in a cache Git is able
700         to avoid unpacking and decompressing frequently used base
701         objects multiple times.
703 Default is 96 MiB on all platforms.  This should be reasonable
704 for all users/operating systems, except on the largest projects.
705 You probably do not need to adjust this value.
707 Common unit suffixes of 'k', 'm', or 'g' are supported.
709 core.bigFileThreshold::
710         Files larger than this size are stored deflated, without
711         attempting delta compression.  Storing large files without
712         delta compression avoids excessive memory usage, at the
713         slight expense of increased disk usage. Additionally files
714         larger than this size are always treated as binary.
716 Default is 512 MiB on all platforms.  This should be reasonable
717 for most projects as source code and other text files can still
718 be delta compressed, but larger binary media files won't be.
720 Common unit suffixes of 'k', 'm', or 'g' are supported.
722 core.excludesFile::
723         Specifies the pathname to the file that contains patterns to
724         describe paths that are not meant to be tracked, in addition
725         to '.gitignore' (per-directory) and '.git/info/exclude'.
726         Defaults to `$XDG_CONFIG_HOME/git/ignore`.
727         If `$XDG_CONFIG_HOME` is either not set or empty, `$HOME/.config/git/ignore`
728         is used instead. See linkgit:gitignore[5].
730 core.askPass::
731         Some commands (e.g. svn and http interfaces) that interactively
732         ask for a password can be told to use an external program given
733         via the value of this variable. Can be overridden by the `GIT_ASKPASS`
734         environment variable. If not set, fall back to the value of the
735         `SSH_ASKPASS` environment variable or, failing that, a simple password
736         prompt. The external program shall be given a suitable prompt as
737         command-line argument and write the password on its STDOUT.
739 core.attributesFile::
740         In addition to '.gitattributes' (per-directory) and
741         '.git/info/attributes', Git looks into this file for attributes
742         (see linkgit:gitattributes[5]). Path expansions are made the same
743         way as for `core.excludesFile`. Its default value is
744         `$XDG_CONFIG_HOME/git/attributes`. If `$XDG_CONFIG_HOME` is either not
745         set or empty, `$HOME/.config/git/attributes` is used instead.
747 core.hooksPath::
748         By default Git will look for your hooks in the
749         '$GIT_DIR/hooks' directory. Set this to different path,
750         e.g. '/etc/git/hooks', and Git will try to find your hooks in
751         that directory, e.g. '/etc/git/hooks/pre-receive' instead of
752         in '$GIT_DIR/hooks/pre-receive'.
754 The path can be either absolute or relative. A relative path is
755 taken as relative to the directory where the hooks are run (see
756 the "DESCRIPTION" section of linkgit:githooks[5]).
758 This configuration variable is useful in cases where you'd like to
759 centrally configure your Git hooks instead of configuring them on a
760 per-repository basis, or as a more flexible and centralized
761 alternative to having an `init.templateDir` where you've changed
762 default hooks.
764 core.editor::
765         Commands such as `commit` and `tag` that let you edit
766         messages by launching an editor use the value of this
767         variable when it is set, and the environment variable
768         `GIT_EDITOR` is not set.  See linkgit:git-var[1].
770 core.commentChar::
771         Commands such as `commit` and `tag` that let you edit
772         messages consider a line that begins with this character
773         commented, and removes them after the editor returns
774         (default '#').
776 If set to "auto", `git-commit` would select a character that is not
777 the beginning character of any line in existing commit messages.
779 core.packedRefsTimeout::
780         The length of time, in milliseconds, to retry when trying to
781         lock the `packed-refs` file. Value 0 means not to retry at
782         all; -1 means to try indefinitely. Default is 1000 (i.e.,
783         retry for 1 second).
785 sequence.editor::
786         Text editor used by `git rebase -i` for editing the rebase instruction file.
787         The value is meant to be interpreted by the shell when it is used.
788         It can be overridden by the `GIT_SEQUENCE_EDITOR` environment variable.
789         When not configured the default commit message editor is used instead.
791 core.pager::
792         Text viewer for use by Git commands (e.g., 'less').  The value
793         is meant to be interpreted by the shell.  The order of preference
794         is the `$GIT_PAGER` environment variable, then `core.pager`
795         configuration, then `$PAGER`, and then the default chosen at
796         compile time (usually 'less').
798 When the `LESS` environment variable is unset, Git sets it to `FRX`
799 (if `LESS` environment variable is set, Git does not change it at
800 all).  If you want to selectively override Git's default setting
801 for `LESS`, you can set `core.pager` to e.g. `less -S`.  This will
802 be passed to the shell by Git, which will translate the final
803 command to `LESS=FRX less -S`. The environment does not set the
804 `S` option but the command line does, instructing less to truncate
805 long lines. Similarly, setting `core.pager` to `less -+F` will
806 deactivate the `F` option specified by the environment from the
807 command-line, deactivating the "quit if one screen" behavior of
808 `less`.  One can specifically activate some flags for particular
809 commands: for example, setting `pager.blame` to `less -S` enables
810 line truncation only for `git blame`.
812 Likewise, when the `LV` environment variable is unset, Git sets it
813 to `-c`.  You can override this setting by exporting `LV` with
814 another value or setting `core.pager` to `lv +c`.
816 core.whitespace::
817         A comma separated list of common whitespace problems to
818         notice.  'git diff' will use `color.diff.whitespace` to
819         highlight them, and 'git apply --whitespace=error' will
820         consider them as errors.  You can prefix `-` to disable
821         any of them (e.g. `-trailing-space`):
823 * `blank-at-eol` treats trailing whitespaces at the end of the line
824   as an error (enabled by default).
825 * `space-before-tab` treats a space character that appears immediately
826   before a tab character in the initial indent part of the line as an
827   error (enabled by default).
828 * `indent-with-non-tab` treats a line that is indented with space
829   characters instead of the equivalent tabs as an error (not enabled by
830   default).
831 * `tab-in-indent` treats a tab character in the initial indent part of
832   the line as an error (not enabled by default).
833 * `blank-at-eof` treats blank lines added at the end of file as an error
834   (enabled by default).
835 * `trailing-space` is a short-hand to cover both `blank-at-eol` and
836   `blank-at-eof`.
837 * `cr-at-eol` treats a carriage-return at the end of line as
838   part of the line terminator, i.e. with it, `trailing-space`
839   does not trigger if the character before such a carriage-return
840   is not a whitespace (not enabled by default).
841 * `tabwidth=<n>` tells how many character positions a tab occupies; this
842   is relevant for `indent-with-non-tab` and when Git fixes `tab-in-indent`
843   errors. The default tab width is 8. Allowed values are 1 to 63.
845 core.fsyncObjectFiles::
846         This boolean will enable 'fsync()' when writing object files.
848 This is a total waste of time and effort on a filesystem that orders
849 data writes properly, but can be useful for filesystems that do not use
850 journalling (traditional UNIX filesystems) or that only journal metadata
851 and not file contents (OS X's HFS+, or Linux ext3 with "data=writeback").
853 core.preloadIndex::
854         Enable parallel index preload for operations like 'git diff'
856 This can speed up operations like 'git diff' and 'git status' especially
857 on filesystems like NFS that have weak caching semantics and thus
858 relatively high IO latencies.  When enabled, Git will do the
859 index comparison to the filesystem data in parallel, allowing
860 overlapping IO's.  Defaults to true.
862 core.createObject::
863         You can set this to 'link', in which case a hardlink followed by
864         a delete of the source are used to make sure that object creation
865         will not overwrite existing objects.
867 On some file system/operating system combinations, this is unreliable.
868 Set this config setting to 'rename' there; However, This will remove the
869 check that makes sure that existing object files will not get overwritten.
871 core.notesRef::
872         When showing commit messages, also show notes which are stored in
873         the given ref.  The ref must be fully qualified.  If the given
874         ref does not exist, it is not an error but means that no
875         notes should be printed.
877 This setting defaults to "refs/notes/commits", and it can be overridden by
878 the `GIT_NOTES_REF` environment variable.  See linkgit:git-notes[1].
880 core.sparseCheckout::
881         Enable "sparse checkout" feature. See section "Sparse checkout" in
882         linkgit:git-read-tree[1] for more information.
884 core.abbrev::
885         Set the length object names are abbreviated to.  If
886         unspecified or set to "auto", an appropriate value is
887         computed based on the approximate number of packed objects
888         in your repository, which hopefully is enough for
889         abbreviated object names to stay unique for some time.
890         The minimum length is 4.
892 add.ignoreErrors::
893 add.ignore-errors (deprecated)::
894         Tells 'git add' to continue adding files when some files cannot be
895         added due to indexing errors. Equivalent to the `--ignore-errors`
896         option of linkgit:git-add[1].  `add.ignore-errors` is deprecated,
897         as it does not follow the usual naming convention for configuration
898         variables.
900 alias.*::
901         Command aliases for the linkgit:git[1] command wrapper - e.g.
902         after defining "alias.last = cat-file commit HEAD", the invocation
903         "git last" is equivalent to "git cat-file commit HEAD". To avoid
904         confusion and troubles with script usage, aliases that
905         hide existing Git commands are ignored. Arguments are split by
906         spaces, the usual shell quoting and escaping is supported.
907         A quote pair or a backslash can be used to quote them.
909 If the alias expansion is prefixed with an exclamation point,
910 it will be treated as a shell command.  For example, defining
911 "alias.new = !gitk --all --not ORIG_HEAD", the invocation
912 "git new" is equivalent to running the shell command
913 "gitk --all --not ORIG_HEAD".  Note that shell commands will be
914 executed from the top-level directory of a repository, which may
915 not necessarily be the current directory.
916 `GIT_PREFIX` is set as returned by running 'git rev-parse --show-prefix'
917 from the original current directory. See linkgit:git-rev-parse[1].
919 am.keepcr::
920         If true, git-am will call git-mailsplit for patches in mbox format
921         with parameter `--keep-cr`. In this case git-mailsplit will
922         not remove `\r` from lines ending with `\r\n`. Can be overridden
923         by giving `--no-keep-cr` from the command line.
924         See linkgit:git-am[1], linkgit:git-mailsplit[1].
926 am.threeWay::
927         By default, `git am` will fail if the patch does not apply cleanly. When
928         set to true, this setting tells `git am` to fall back on 3-way merge if
929         the patch records the identity of blobs it is supposed to apply to and
930         we have those blobs available locally (equivalent to giving the `--3way`
931         option from the command line). Defaults to `false`.
932         See linkgit:git-am[1].
934 apply.ignoreWhitespace::
935         When set to 'change', tells 'git apply' to ignore changes in
936         whitespace, in the same way as the `--ignore-space-change`
937         option.
938         When set to one of: no, none, never, false tells 'git apply' to
939         respect all whitespace differences.
940         See linkgit:git-apply[1].
942 apply.whitespace::
943         Tells 'git apply' how to handle whitespaces, in the same way
944         as the `--whitespace` option. See linkgit:git-apply[1].
946 branch.autoSetupMerge::
947         Tells 'git branch' and 'git checkout' to set up new branches
948         so that linkgit:git-pull[1] will appropriately merge from the
949         starting point branch. Note that even if this option is not set,
950         this behavior can be chosen per-branch using the `--track`
951         and `--no-track` options. The valid settings are: `false` -- no
952         automatic setup is done; `true` -- automatic setup is done when the
953         starting point is a remote-tracking branch; `always` --
954         automatic setup is done when the starting point is either a
955         local branch or remote-tracking
956         branch. This option defaults to true.
958 branch.autoSetupRebase::
959         When a new branch is created with 'git branch' or 'git checkout'
960         that tracks another branch, this variable tells Git to set
961         up pull to rebase instead of merge (see "branch.<name>.rebase").
962         When `never`, rebase is never automatically set to true.
963         When `local`, rebase is set to true for tracked branches of
964         other local branches.
965         When `remote`, rebase is set to true for tracked branches of
966         remote-tracking branches.
967         When `always`, rebase will be set to true for all tracking
968         branches.
969         See "branch.autoSetupMerge" for details on how to set up a
970         branch to track another branch.
971         This option defaults to never.
973 branch.<name>.remote::
974         When on branch <name>, it tells 'git fetch' and 'git push'
975         which remote to fetch from/push to.  The remote to push to
976         may be overridden with `remote.pushDefault` (for all branches).
977         The remote to push to, for the current branch, may be further
978         overridden by `branch.<name>.pushRemote`.  If no remote is
979         configured, or if you are not on any branch, it defaults to
980         `origin` for fetching and `remote.pushDefault` for pushing.
981         Additionally, `.` (a period) is the current local repository
982         (a dot-repository), see `branch.<name>.merge`'s final note below.
984 branch.<name>.pushRemote::
985         When on branch <name>, it overrides `branch.<name>.remote` for
986         pushing.  It also overrides `remote.pushDefault` for pushing
987         from branch <name>.  When you pull from one place (e.g. your
988         upstream) and push to another place (e.g. your own publishing
989         repository), you would want to set `remote.pushDefault` to
990         specify the remote to push to for all branches, and use this
991         option to override it for a specific branch.
993 branch.<name>.merge::
994         Defines, together with branch.<name>.remote, the upstream branch
995         for the given branch. It tells 'git fetch'/'git pull'/'git rebase' which
996         branch to merge and can also affect 'git push' (see push.default).
997         When in branch <name>, it tells 'git fetch' the default
998         refspec to be marked for merging in FETCH_HEAD. The value is
999         handled like the remote part of a refspec, and must match a
1000         ref which is fetched from the remote given by
1001         "branch.<name>.remote".
1002         The merge information is used by 'git pull' (which at first calls
1003         'git fetch') to lookup the default branch for merging. Without
1004         this option, 'git pull' defaults to merge the first refspec fetched.
1005         Specify multiple values to get an octopus merge.
1006         If you wish to setup 'git pull' so that it merges into <name> from
1007         another branch in the local repository, you can point
1008         branch.<name>.merge to the desired branch, and use the relative path
1009         setting `.` (a period) for branch.<name>.remote.
1011 branch.<name>.mergeOptions::
1012         Sets default options for merging into branch <name>. The syntax and
1013         supported options are the same as those of linkgit:git-merge[1], but
1014         option values containing whitespace characters are currently not
1015         supported.
1017 branch.<name>.rebase::
1018         When true, rebase the branch <name> on top of the fetched branch,
1019         instead of merging the default branch from the default remote when
1020         "git pull" is run. See "pull.rebase" for doing this in a non
1021         branch-specific manner.
1023 When preserve, also pass `--preserve-merges` along to 'git rebase'
1024 so that locally committed merge commits will not be flattened
1025 by running 'git pull'.
1027 When the value is `interactive`, the rebase is run in interactive mode.
1029 *NOTE*: this is a possibly dangerous operation; do *not* use
1030 it unless you understand the implications (see linkgit:git-rebase[1]
1031 for details).
1033 branch.<name>.description::
1034         Branch description, can be edited with
1035         `git branch --edit-description`. Branch description is
1036         automatically added in the format-patch cover letter or
1037         request-pull summary.
1039 browser.<tool>.cmd::
1040         Specify the command to invoke the specified browser. The
1041         specified command is evaluated in shell with the URLs passed
1042         as arguments. (See linkgit:git-web{litdd}browse[1].)
1044 browser.<tool>.path::
1045         Override the path for the given tool that may be used to
1046         browse HTML help (see `-w` option in linkgit:git-help[1]) or a
1047         working repository in gitweb (see linkgit:git-instaweb[1]).
1049 clean.requireForce::
1050         A boolean to make git-clean do nothing unless given -f,
1051         -i or -n.   Defaults to true.
1053 color.branch::
1054         A boolean to enable/disable color in the output of
1055         linkgit:git-branch[1]. May be set to `always`,
1056         `false` (or `never`) or `auto` (or `true`), in which case colors are used
1057         only when the output is to a terminal. If unset, then the
1058         value of `color.ui` is used (`auto` by default).
1060 color.branch.<slot>::
1061         Use customized color for branch coloration. `<slot>` is one of
1062         `current` (the current branch), `local` (a local branch),
1063         `remote` (a remote-tracking branch in refs/remotes/),
1064         `upstream` (upstream tracking branch), `plain` (other
1065         refs).
1067 color.diff::
1068         Whether to use ANSI escape sequences to add color to patches.
1069         If this is set to `always`, linkgit:git-diff[1],
1070         linkgit:git-log[1], and linkgit:git-show[1] will use color
1071         for all patches.  If it is set to `true` or `auto`, those
1072         commands will only use color when output is to the terminal.
1073         If unset, then the value of `color.ui` is used (`auto` by
1074         default).
1076 This does not affect linkgit:git-format-patch[1] or the
1077 'git-diff-{asterisk}' plumbing commands.  Can be overridden on the
1078 command line with the `--color[=<when>]` option.
1080 color.diff.<slot>::
1081         Use customized color for diff colorization.  `<slot>` specifies
1082         which part of the patch to use the specified color, and is one
1083         of `context` (context text - `plain` is a historical synonym),
1084         `meta` (metainformation), `frag`
1085         (hunk header), 'func' (function in hunk header), `old` (removed lines),
1086         `new` (added lines), `commit` (commit headers), or `whitespace`
1087         (highlighting whitespace errors).
1089 color.decorate.<slot>::
1090         Use customized color for 'git log --decorate' output.  `<slot>` is one
1091         of `branch`, `remoteBranch`, `tag`, `stash` or `HEAD` for local
1092         branches, remote-tracking branches, tags, stash and HEAD, respectively.
1094 color.grep::
1095         When set to `always`, always highlight matches.  When `false` (or
1096         `never`), never.  When set to `true` or `auto`, use color only
1097         when the output is written to the terminal.  If unset, then the
1098         value of `color.ui` is used (`auto` by default).
1100 color.grep.<slot>::
1101         Use customized color for grep colorization.  `<slot>` specifies which
1102         part of the line to use the specified color, and is one of
1105 `context`;;
1106         non-matching text in context lines (when using `-A`, `-B`, or `-C`)
1107 `filename`;;
1108         filename prefix (when not using `-h`)
1109 `function`;;
1110         function name lines (when using `-p`)
1111 `linenumber`;;
1112         line number prefix (when using `-n`)
1113 `match`;;
1114         matching text (same as setting `matchContext` and `matchSelected`)
1115 `matchContext`;;
1116         matching text in context lines
1117 `matchSelected`;;
1118         matching text in selected lines
1119 `selected`;;
1120         non-matching text in selected lines
1121 `separator`;;
1122         separators between fields on a line (`:`, `-`, and `=`)
1123         and between hunks (`--`)
1126 color.interactive::
1127         When set to `always`, always use colors for interactive prompts
1128         and displays (such as those used by "git-add --interactive" and
1129         "git-clean --interactive"). When false (or `never`), never.
1130         When set to `true` or `auto`, use colors only when the output is
1131         to the terminal. If unset, then the value of `color.ui` is
1132         used (`auto` by default).
1134 color.interactive.<slot>::
1135         Use customized color for 'git add --interactive' and 'git clean
1136         --interactive' output. `<slot>` may be `prompt`, `header`, `help`
1137         or `error`, for four distinct types of normal output from
1138         interactive commands.
1140 color.pager::
1141         A boolean to enable/disable colored output when the pager is in
1142         use (default is true).
1144 color.showBranch::
1145         A boolean to enable/disable color in the output of
1146         linkgit:git-show-branch[1]. May be set to `always`,
1147         `false` (or `never`) or `auto` (or `true`), in which case colors are used
1148         only when the output is to a terminal. If unset, then the
1149         value of `color.ui` is used (`auto` by default).
1151 color.status::
1152         A boolean to enable/disable color in the output of
1153         linkgit:git-status[1]. May be set to `always`,
1154         `false` (or `never`) or `auto` (or `true`), in which case colors are used
1155         only when the output is to a terminal. If unset, then the
1156         value of `color.ui` is used (`auto` by default).
1158 color.status.<slot>::
1159         Use customized color for status colorization. `<slot>` is
1160         one of `header` (the header text of the status message),
1161         `added` or `updated` (files which are added but not committed),
1162         `changed` (files which are changed but not added in the index),
1163         `untracked` (files which are not tracked by Git),
1164         `branch` (the current branch),
1165         `nobranch` (the color the 'no branch' warning is shown in, defaulting
1166         to red),
1167         `localBranch` or `remoteBranch` (the local and remote branch names,
1168         respectively, when branch and tracking information is displayed in the
1169         status short-format), or
1170         `unmerged` (files which have unmerged changes).
1172 color.ui::
1173         This variable determines the default value for variables such
1174         as `color.diff` and `color.grep` that control the use of color
1175         per command family. Its scope will expand as more commands learn
1176         configuration to set a default for the `--color` option.  Set it
1177         to `false` or `never` if you prefer Git commands not to use
1178         color unless enabled explicitly with some other configuration
1179         or the `--color` option. Set it to `always` if you want all
1180         output not intended for machine consumption to use color, to
1181         `true` or `auto` (this is the default since Git 1.8.4) if you
1182         want such output to use color when written to the terminal.
1184 column.ui::
1185         Specify whether supported commands should output in columns.
1186         This variable consists of a list of tokens separated by spaces
1187         or commas:
1189 These options control when the feature should be enabled
1190 (defaults to 'never'):
1193 `always`;;
1194         always show in columns
1195 `never`;;
1196         never show in columns
1197 `auto`;;
1198         show in columns if the output is to the terminal
1201 These options control layout (defaults to 'column').  Setting any
1202 of these implies 'always' if none of 'always', 'never', or 'auto' are
1203 specified.
1206 `column`;;
1207         fill columns before rows
1208 `row`;;
1209         fill rows before columns
1210 `plain`;;
1211         show in one column
1214 Finally, these options can be combined with a layout option (defaults
1215 to 'nodense'):
1218 `dense`;;
1219         make unequal size columns to utilize more space
1220 `nodense`;;
1221         make equal size columns
1224 column.branch::
1225         Specify whether to output branch listing in `git branch` in columns.
1226         See `column.ui` for details.
1228 column.clean::
1229         Specify the layout when list items in `git clean -i`, which always
1230         shows files and directories in columns. See `column.ui` for details.
1232 column.status::
1233         Specify whether to output untracked files in `git status` in columns.
1234         See `column.ui` for details.
1236 column.tag::
1237         Specify whether to output tag listing in `git tag` in columns.
1238         See `column.ui` for details.
1240 commit.cleanup::
1241         This setting overrides the default of the `--cleanup` option in
1242         `git commit`. See linkgit:git-commit[1] for details. Changing the
1243         default can be useful when you always want to keep lines that begin
1244         with comment character `#` in your log message, in which case you
1245         would do `git config commit.cleanup whitespace` (note that you will
1246         have to remove the help lines that begin with `#` in the commit log
1247         template yourself, if you do this).
1249 commit.gpgSign::
1251         A boolean to specify whether all commits should be GPG signed.
1252         Use of this option when doing operations such as rebase can
1253         result in a large number of commits being signed. It may be
1254         convenient to use an agent to avoid typing your GPG passphrase
1255         several times.
1257 commit.status::
1258         A boolean to enable/disable inclusion of status information in the
1259         commit message template when using an editor to prepare the commit
1260         message.  Defaults to true.
1262 commit.template::
1263         Specify the pathname of a file to use as the template for
1264         new commit messages.
1266 commit.verbose::
1267         A boolean or int to specify the level of verbose with `git commit`.
1268         See linkgit:git-commit[1].
1270 credential.helper::
1271         Specify an external helper to be called when a username or
1272         password credential is needed; the helper may consult external
1273         storage to avoid prompting the user for the credentials. Note
1274         that multiple helpers may be defined. See linkgit:gitcredentials[7]
1275         for details.
1277 credential.useHttpPath::
1278         When acquiring credentials, consider the "path" component of an http
1279         or https URL to be important. Defaults to false. See
1280         linkgit:gitcredentials[7] for more information.
1282 credential.username::
1283         If no username is set for a network authentication, use this username
1284         by default. See credential.<context>.* below, and
1285         linkgit:gitcredentials[7].
1287 credential.<url>.*::
1288         Any of the credential.* options above can be applied selectively to
1289         some credentials. For example "credential.https://example.com.username"
1290         would set the default username only for https connections to
1291         example.com. See linkgit:gitcredentials[7] for details on how URLs are
1292         matched.
1294 credentialCache.ignoreSIGHUP::
1295         Tell git-credential-cache--daemon to ignore SIGHUP, instead of quitting.
1297 include::diff-config.txt[]
1299 difftool.<tool>.path::
1300         Override the path for the given tool.  This is useful in case
1301         your tool is not in the PATH.
1303 difftool.<tool>.cmd::
1304         Specify the command to invoke the specified diff tool.
1305         The specified command is evaluated in shell with the following
1306         variables available:  'LOCAL' is set to the name of the temporary
1307         file containing the contents of the diff pre-image and 'REMOTE'
1308         is set to the name of the temporary file containing the contents
1309         of the diff post-image.
1311 difftool.prompt::
1312         Prompt before each invocation of the diff tool.
1314 fastimport.unpackLimit::
1315         If the number of objects imported by linkgit:git-fast-import[1]
1316         is below this limit, then the objects will be unpacked into
1317         loose object files.  However if the number of imported objects
1318         equals or exceeds this limit then the pack will be stored as a
1319         pack.  Storing the pack from a fast-import can make the import
1320         operation complete faster, especially on slow filesystems.  If
1321         not set, the value of `transfer.unpackLimit` is used instead.
1323 fetch.recurseSubmodules::
1324         This option can be either set to a boolean value or to 'on-demand'.
1325         Setting it to a boolean changes the behavior of fetch and pull to
1326         unconditionally recurse into submodules when set to true or to not
1327         recurse at all when set to false. When set to 'on-demand' (the default
1328         value), fetch and pull will only recurse into a populated submodule
1329         when its superproject retrieves a commit that updates the submodule's
1330         reference.
1332 fetch.fsckObjects::
1333         If it is set to true, git-fetch-pack will check all fetched
1334         objects. It will abort in the case of a malformed object or a
1335         broken link. The result of an abort are only dangling objects.
1336         Defaults to false. If not set, the value of `transfer.fsckObjects`
1337         is used instead.
1339 fetch.unpackLimit::
1340         If the number of objects fetched over the Git native
1341         transfer is below this
1342         limit, then the objects will be unpacked into loose object
1343         files. However if the number of received objects equals or
1344         exceeds this limit then the received pack will be stored as
1345         a pack, after adding any missing delta bases.  Storing the
1346         pack from a push can make the push operation complete faster,
1347         especially on slow filesystems.  If not set, the value of
1348         `transfer.unpackLimit` is used instead.
1350 fetch.prune::
1351         If true, fetch will automatically behave as if the `--prune`
1352         option was given on the command line.  See also `remote.<name>.prune`.
1354 fetch.output::
1355         Control how ref update status is printed. Valid values are
1356         `full` and `compact`. Default value is `full`. See section
1357         OUTPUT in linkgit:git-fetch[1] for detail.
1359 format.attach::
1360         Enable multipart/mixed attachments as the default for
1361         'format-patch'.  The value can also be a double quoted string
1362         which will enable attachments as the default and set the
1363         value as the boundary.  See the --attach option in
1364         linkgit:git-format-patch[1].
1366 format.from::
1367         Provides the default value for the `--from` option to format-patch.
1368         Accepts a boolean value, or a name and email address.  If false,
1369         format-patch defaults to `--no-from`, using commit authors directly in
1370         the "From:" field of patch mails.  If true, format-patch defaults to
1371         `--from`, using your committer identity in the "From:" field of patch
1372         mails and including a "From:" field in the body of the patch mail if
1373         different.  If set to a non-boolean value, format-patch uses that
1374         value instead of your committer identity.  Defaults to false.
1376 format.numbered::
1377         A boolean which can enable or disable sequence numbers in patch
1378         subjects.  It defaults to "auto" which enables it only if there
1379         is more than one patch.  It can be enabled or disabled for all
1380         messages by setting it to "true" or "false".  See --numbered
1381         option in linkgit:git-format-patch[1].
1383 format.headers::
1384         Additional email headers to include in a patch to be submitted
1385         by mail.  See linkgit:git-format-patch[1].
1387 format.to::
1388 format.cc::
1389         Additional recipients to include in a patch to be submitted
1390         by mail.  See the --to and --cc options in
1391         linkgit:git-format-patch[1].
1393 format.subjectPrefix::
1394         The default for format-patch is to output files with the '[PATCH]'
1395         subject prefix. Use this variable to change that prefix.
1397 format.signature::
1398         The default for format-patch is to output a signature containing
1399         the Git version number. Use this variable to change that default.
1400         Set this variable to the empty string ("") to suppress
1401         signature generation.
1403 format.signatureFile::
1404         Works just like format.signature except the contents of the
1405         file specified by this variable will be used as the signature.
1407 format.suffix::
1408         The default for format-patch is to output files with the suffix
1409         `.patch`. Use this variable to change that suffix (make sure to
1410         include the dot if you want it).
1412 format.pretty::
1413         The default pretty format for log/show/whatchanged command,
1414         See linkgit:git-log[1], linkgit:git-show[1],
1415         linkgit:git-whatchanged[1].
1417 format.thread::
1418         The default threading style for 'git format-patch'.  Can be
1419         a boolean value, or `shallow` or `deep`.  `shallow` threading
1420         makes every mail a reply to the head of the series,
1421         where the head is chosen from the cover letter, the
1422         `--in-reply-to`, and the first patch mail, in this order.
1423         `deep` threading makes every mail a reply to the previous one.
1424         A true boolean value is the same as `shallow`, and a false
1425         value disables threading.
1427 format.signOff::
1428         A boolean value which lets you enable the `-s/--signoff` option of
1429         format-patch by default. *Note:* Adding the Signed-off-by: line to a
1430         patch should be a conscious act and means that you certify you have
1431         the rights to submit this work under the same open source license.
1432         Please see the 'SubmittingPatches' document for further discussion.
1434 format.coverLetter::
1435         A boolean that controls whether to generate a cover-letter when
1436         format-patch is invoked, but in addition can be set to "auto", to
1437         generate a cover-letter only when there's more than one patch.
1439 format.outputDirectory::
1440         Set a custom directory to store the resulting files instead of the
1441         current working directory.
1443 format.useAutoBase::
1444         A boolean value which lets you enable the `--base=auto` option of
1445         format-patch by default.
1447 filter.<driver>.clean::
1448         The command which is used to convert the content of a worktree
1449         file to a blob upon checkin.  See linkgit:gitattributes[5] for
1450         details.
1452 filter.<driver>.smudge::
1453         The command which is used to convert the content of a blob
1454         object to a worktree file upon checkout.  See
1455         linkgit:gitattributes[5] for details.
1457 fsck.<msg-id>::
1458         Allows overriding the message type (error, warn or ignore) of a
1459         specific message ID such as `missingEmail`.
1461 For convenience, fsck prefixes the error/warning with the message ID,
1462 e.g.  "missingEmail: invalid author/committer line - missing email" means
1463 that setting `fsck.missingEmail = ignore` will hide that issue.
1465 This feature is intended to support working with legacy repositories
1466 which cannot be repaired without disruptive changes.
1468 fsck.skipList::
1469         The path to a sorted list of object names (i.e. one SHA-1 per
1470         line) that are known to be broken in a non-fatal way and should
1471         be ignored. This feature is useful when an established project
1472         should be accepted despite early commits containing errors that
1473         can be safely ignored such as invalid committer email addresses.
1474         Note: corrupt objects cannot be skipped with this setting.
1476 gc.aggressiveDepth::
1477         The depth parameter used in the delta compression
1478         algorithm used by 'git gc --aggressive'.  This defaults
1479         to 50.
1481 gc.aggressiveWindow::
1482         The window size parameter used in the delta compression
1483         algorithm used by 'git gc --aggressive'.  This defaults
1484         to 250.
1486 gc.auto::
1487         When there are approximately more than this many loose
1488         objects in the repository, `git gc --auto` will pack them.
1489         Some Porcelain commands use this command to perform a
1490         light-weight garbage collection from time to time.  The
1491         default value is 6700.  Setting this to 0 disables it.
1493 gc.autoPackLimit::
1494         When there are more than this many packs that are not
1495         marked with `*.keep` file in the repository, `git gc
1496         --auto` consolidates them into one larger pack.  The
1497         default value is 50.  Setting this to 0 disables it.
1499 gc.autoDetach::
1500         Make `git gc --auto` return immediately and run in background
1501         if the system supports it. Default is true.
1503 gc.logExpiry::
1504         If the file gc.log exists, then `git gc --auto` won't run
1505         unless that file is more than 'gc.logExpiry' old.  Default is
1506         "1.day".  See `gc.pruneExpire` for more ways to specify its
1507         value.
1509 gc.packRefs::
1510         Running `git pack-refs` in a repository renders it
1511         unclonable by Git versions prior to 1.5.1.2 over dumb
1512         transports such as HTTP.  This variable determines whether
1513         'git gc' runs `git pack-refs`. This can be set to `notbare`
1514         to enable it within all non-bare repos or it can be set to a
1515         boolean value.  The default is `true`.
1517 gc.pruneExpire::
1518         When 'git gc' is run, it will call 'prune --expire 2.weeks.ago'.
1519         Override the grace period with this config variable.  The value
1520         "now" may be used to disable this grace period and always prune
1521         unreachable objects immediately, or "never" may be used to
1522         suppress pruning.  This feature helps prevent corruption when
1523         'git gc' runs concurrently with another process writing to the
1524         repository; see the "NOTES" section of linkgit:git-gc[1].
1526 gc.worktreePruneExpire::
1527         When 'git gc' is run, it calls
1528         'git worktree prune --expire 3.months.ago'.
1529         This config variable can be used to set a different grace
1530         period. The value "now" may be used to disable the grace
1531         period and prune `$GIT_DIR/worktrees` immediately, or "never"
1532         may be used to suppress pruning.
1534 gc.reflogExpire::
1535 gc.<pattern>.reflogExpire::
1536         'git reflog expire' removes reflog entries older than
1537         this time; defaults to 90 days. The value "now" expires all
1538         entries immediately, and "never" suppresses expiration
1539         altogether. With "<pattern>" (e.g.
1540         "refs/stash") in the middle the setting applies only to
1541         the refs that match the <pattern>.
1543 gc.reflogExpireUnreachable::
1544 gc.<pattern>.reflogExpireUnreachable::
1545         'git reflog expire' removes reflog entries older than
1546         this time and are not reachable from the current tip;
1547         defaults to 30 days. The value "now" expires all entries
1548         immediately, and "never" suppresses expiration altogether.
1549         With "<pattern>" (e.g. "refs/stash")
1550         in the middle, the setting applies only to the refs that
1551         match the <pattern>.
1553 gc.rerereResolved::
1554         Records of conflicted merge you resolved earlier are
1555         kept for this many days when 'git rerere gc' is run.
1556         The default is 60 days.  See linkgit:git-rerere[1].
1558 gc.rerereUnresolved::
1559         Records of conflicted merge you have not resolved are
1560         kept for this many days when 'git rerere gc' is run.
1561         The default is 15 days.  See linkgit:git-rerere[1].
1563 gitcvs.commitMsgAnnotation::
1564         Append this string to each commit message. Set to empty string
1565         to disable this feature. Defaults to "via git-CVS emulator".
1567 gitcvs.enabled::
1568         Whether the CVS server interface is enabled for this repository.
1569         See linkgit:git-cvsserver[1].
1571 gitcvs.logFile::
1572         Path to a log file where the CVS server interface well... logs
1573         various stuff. See linkgit:git-cvsserver[1].
1575 gitcvs.usecrlfattr::
1576         If true, the server will look up the end-of-line conversion
1577         attributes for files to determine the `-k` modes to use. If
1578         the attributes force Git to treat a file as text,
1579         the `-k` mode will be left blank so CVS clients will
1580         treat it as text. If they suppress text conversion, the file
1581         will be set with '-kb' mode, which suppresses any newline munging
1582         the client might otherwise do. If the attributes do not allow
1583         the file type to be determined, then `gitcvs.allBinary` is
1584         used. See linkgit:gitattributes[5].
1586 gitcvs.allBinary::
1587         This is used if `gitcvs.usecrlfattr` does not resolve
1588         the correct '-kb' mode to use. If true, all
1589         unresolved files are sent to the client in
1590         mode '-kb'. This causes the client to treat them
1591         as binary files, which suppresses any newline munging it
1592         otherwise might do. Alternatively, if it is set to "guess",
1593         then the contents of the file are examined to decide if
1594         it is binary, similar to `core.autocrlf`.
1596 gitcvs.dbName::
1597         Database used by git-cvsserver to cache revision information
1598         derived from the Git repository. The exact meaning depends on the
1599         used database driver, for SQLite (which is the default driver) this
1600         is a filename. Supports variable substitution (see
1601         linkgit:git-cvsserver[1] for details). May not contain semicolons (`;`).
1602         Default: '%Ggitcvs.%m.sqlite'
1604 gitcvs.dbDriver::
1605         Used Perl DBI driver. You can specify any available driver
1606         for this here, but it might not work. git-cvsserver is tested
1607         with 'DBD::SQLite', reported to work with 'DBD::Pg', and
1608         reported *not* to work with 'DBD::mysql'. Experimental feature.
1609         May not contain double colons (`:`). Default: 'SQLite'.
1610         See linkgit:git-cvsserver[1].
1612 gitcvs.dbUser, gitcvs.dbPass::
1613         Database user and password. Only useful if setting `gitcvs.dbDriver`,
1614         since SQLite has no concept of database users and/or passwords.
1615         'gitcvs.dbUser' supports variable substitution (see
1616         linkgit:git-cvsserver[1] for details).
1618 gitcvs.dbTableNamePrefix::
1619         Database table name prefix.  Prepended to the names of any
1620         database tables used, allowing a single database to be used
1621         for several repositories.  Supports variable substitution (see
1622         linkgit:git-cvsserver[1] for details).  Any non-alphabetic
1623         characters will be replaced with underscores.
1625 All gitcvs variables except for `gitcvs.usecrlfattr` and
1626 `gitcvs.allBinary` can also be specified as
1627 'gitcvs.<access_method>.<varname>' (where 'access_method'
1628 is one of "ext" and "pserver") to make them apply only for the given
1629 access method.
1631 gitweb.category::
1632 gitweb.description::
1633 gitweb.owner::
1634 gitweb.url::
1635         See linkgit:gitweb[1] for description.
1637 gitweb.avatar::
1638 gitweb.blame::
1639 gitweb.grep::
1640 gitweb.highlight::
1641 gitweb.patches::
1642 gitweb.pickaxe::
1643 gitweb.remote_heads::
1644 gitweb.showSizes::
1645 gitweb.snapshot::
1646         See linkgit:gitweb.conf[5] for description.
1648 grep.lineNumber::
1649         If set to true, enable `-n` option by default.
1651 grep.patternType::
1652         Set the default matching behavior. Using a value of 'basic', 'extended',
1653         'fixed', or 'perl' will enable the `--basic-regexp`, `--extended-regexp`,
1654         `--fixed-strings`, or `--perl-regexp` option accordingly, while the
1655         value 'default' will return to the default matching behavior.
1657 grep.extendedRegexp::
1658         If set to true, enable `--extended-regexp` option by default. This
1659         option is ignored when the `grep.patternType` option is set to a value
1660         other than 'default'.
1662 grep.threads::
1663         Number of grep worker threads to use.
1664         See `grep.threads` in linkgit:git-grep[1] for more information.
1666 grep.fallbackToNoIndex::
1667         If set to true, fall back to git grep --no-index if git grep
1668         is executed outside of a git repository.  Defaults to false.
1670 gpg.program::
1671         Use this custom program instead of "`gpg`" found on `$PATH` when
1672         making or verifying a PGP signature. The program must support the
1673         same command-line interface as GPG, namely, to verify a detached
1674         signature, "`gpg --verify $file - <$signature`" is run, and the
1675         program is expected to signal a good signature by exiting with
1676         code 0, and to generate an ASCII-armored detached signature, the
1677         standard input of "`gpg -bsau $key`" is fed with the contents to be
1678         signed, and the program is expected to send the result to its
1679         standard output.
1681 gui.commitMsgWidth::
1682         Defines how wide the commit message window is in the
1683         linkgit:git-gui[1]. "75" is the default.
1685 gui.diffContext::
1686         Specifies how many context lines should be used in calls to diff
1687         made by the linkgit:git-gui[1]. The default is "5".
1689 gui.displayUntracked::
1690         Determines if linkgit:git-gui[1] shows untracked files
1691         in the file list. The default is "true".
1693 gui.encoding::
1694         Specifies the default encoding to use for displaying of
1695         file contents in linkgit:git-gui[1] and linkgit:gitk[1].
1696         It can be overridden by setting the 'encoding' attribute
1697         for relevant files (see linkgit:gitattributes[5]).
1698         If this option is not set, the tools default to the
1699         locale encoding.
1701 gui.matchTrackingBranch::
1702         Determines if new branches created with linkgit:git-gui[1] should
1703         default to tracking remote branches with matching names or
1704         not. Default: "false".
1706 gui.newBranchTemplate::
1707         Is used as suggested name when creating new branches using the
1708         linkgit:git-gui[1].
1710 gui.pruneDuringFetch::
1711         "true" if linkgit:git-gui[1] should prune remote-tracking branches when
1712         performing a fetch. The default value is "false".
1714 gui.trustmtime::
1715         Determines if linkgit:git-gui[1] should trust the file modification
1716         timestamp or not. By default the timestamps are not trusted.
1718 gui.spellingDictionary::
1719         Specifies the dictionary used for spell checking commit messages in
1720         the linkgit:git-gui[1]. When set to "none" spell checking is turned
1721         off.
1723 gui.fastCopyBlame::
1724         If true, 'git gui blame' uses `-C` instead of `-C -C` for original
1725         location detection. It makes blame significantly faster on huge
1726         repositories at the expense of less thorough copy detection.
1728 gui.copyBlameThreshold::
1729         Specifies the threshold to use in 'git gui blame' original location
1730         detection, measured in alphanumeric characters. See the
1731         linkgit:git-blame[1] manual for more information on copy detection.
1733 gui.blamehistoryctx::
1734         Specifies the radius of history context in days to show in
1735         linkgit:gitk[1] for the selected commit, when the `Show History
1736         Context` menu item is invoked from 'git gui blame'. If this
1737         variable is set to zero, the whole history is shown.
1739 guitool.<name>.cmd::
1740         Specifies the shell command line to execute when the corresponding item
1741         of the linkgit:git-gui[1] `Tools` menu is invoked. This option is
1742         mandatory for every tool. The command is executed from the root of
1743         the working directory, and in the environment it receives the name of
1744         the tool as `GIT_GUITOOL`, the name of the currently selected file as
1745         'FILENAME', and the name of the current branch as 'CUR_BRANCH' (if
1746         the head is detached, 'CUR_BRANCH' is empty).
1748 guitool.<name>.needsFile::
1749         Run the tool only if a diff is selected in the GUI. It guarantees
1750         that 'FILENAME' is not empty.
1752 guitool.<name>.noConsole::
1753         Run the command silently, without creating a window to display its
1754         output.
1756 guitool.<name>.noRescan::
1757         Don't rescan the working directory for changes after the tool
1758         finishes execution.
1760 guitool.<name>.confirm::
1761         Show a confirmation dialog before actually running the tool.
1763 guitool.<name>.argPrompt::
1764         Request a string argument from the user, and pass it to the tool
1765         through the `ARGS` environment variable. Since requesting an
1766         argument implies confirmation, the 'confirm' option has no effect
1767         if this is enabled. If the option is set to 'true', 'yes', or '1',
1768         the dialog uses a built-in generic prompt; otherwise the exact
1769         value of the variable is used.
1771 guitool.<name>.revPrompt::
1772         Request a single valid revision from the user, and set the
1773         `REVISION` environment variable. In other aspects this option
1774         is similar to 'argPrompt', and can be used together with it.
1776 guitool.<name>.revUnmerged::
1777         Show only unmerged branches in the 'revPrompt' subdialog.
1778         This is useful for tools similar to merge or rebase, but not
1779         for things like checkout or reset.
1781 guitool.<name>.title::
1782         Specifies the title to use for the prompt dialog. The default
1783         is the tool name.
1785 guitool.<name>.prompt::
1786         Specifies the general prompt string to display at the top of
1787         the dialog, before subsections for 'argPrompt' and 'revPrompt'.
1788         The default value includes the actual command.
1790 help.browser::
1791         Specify the browser that will be used to display help in the
1792         'web' format. See linkgit:git-help[1].
1794 help.format::
1795         Override the default help format used by linkgit:git-help[1].
1796         Values 'man', 'info', 'web' and 'html' are supported. 'man' is
1797         the default. 'web' and 'html' are the same.
1799 help.autoCorrect::
1800         Automatically correct and execute mistyped commands after
1801         waiting for the given number of deciseconds (0.1 sec). If more
1802         than one command can be deduced from the entered text, nothing
1803         will be executed.  If the value of this option is negative,
1804         the corrected command will be executed immediately. If the
1805         value is 0 - the command will be just shown but not executed.
1806         This is the default.
1808 help.htmlPath::
1809         Specify the path where the HTML documentation resides. File system paths
1810         and URLs are supported. HTML pages will be prefixed with this path when
1811         help is displayed in the 'web' format. This defaults to the documentation
1812         path of your Git installation.
1814 http.proxy::
1815         Override the HTTP proxy, normally configured using the 'http_proxy',
1816         'https_proxy', and 'all_proxy' environment variables (see `curl(1)`). In
1817         addition to the syntax understood by curl, it is possible to specify a
1818         proxy string with a user name but no password, in which case git will
1819         attempt to acquire one in the same way it does for other credentials. See
1820         linkgit:gitcredentials[7] for more information. The syntax thus is
1821         '[protocol://][user[:password]@]proxyhost[:port]'. This can be overridden
1822         on a per-remote basis; see remote.<name>.proxy
1824 http.proxyAuthMethod::
1825         Set the method with which to authenticate against the HTTP proxy. This
1826         only takes effect if the configured proxy string contains a user name part
1827         (i.e. is of the form 'user@host' or 'user@host:port'). This can be
1828         overridden on a per-remote basis; see `remote.<name>.proxyAuthMethod`.
1829         Both can be overridden by the `GIT_HTTP_PROXY_AUTHMETHOD` environment
1830         variable.  Possible values are:
1833 * `anyauth` - Automatically pick a suitable authentication method. It is
1834   assumed that the proxy answers an unauthenticated request with a 407
1835   status code and one or more Proxy-authenticate headers with supported
1836   authentication methods. This is the default.
1837 * `basic` - HTTP Basic authentication
1838 * `digest` - HTTP Digest authentication; this prevents the password from being
1839   transmitted to the proxy in clear text
1840 * `negotiate` - GSS-Negotiate authentication (compare the --negotiate option
1841   of `curl(1)`)
1842 * `ntlm` - NTLM authentication (compare the --ntlm option of `curl(1)`)
1845 http.emptyAuth::
1846         Attempt authentication without seeking a username or password.  This
1847         can be used to attempt GSS-Negotiate authentication without specifying
1848         a username in the URL, as libcurl normally requires a username for
1849         authentication.
1851 http.delegation::
1852         Control GSSAPI credential delegation. The delegation is disabled
1853         by default in libcurl since version 7.21.7. Set parameter to tell
1854         the server what it is allowed to delegate when it comes to user
1855         credentials. Used with GSS/kerberos. Possible values are:
1858 * `none` - Don't allow any delegation.
1859 * `policy` - Delegates if and only if the OK-AS-DELEGATE flag is set in the
1860   Kerberos service ticket, which is a matter of realm policy.
1861 * `always` - Unconditionally allow the server to delegate.
1865 http.extraHeader::
1866         Pass an additional HTTP header when communicating with a server.  If
1867         more than one such entry exists, all of them are added as extra
1868         headers.  To allow overriding the settings inherited from the system
1869         config, an empty value will reset the extra headers to the empty list.
1871 http.cookieFile::
1872         The pathname of a file containing previously stored cookie lines,
1873         which should be used
1874         in the Git http session, if they match the server. The file format
1875         of the file to read cookies from should be plain HTTP headers or
1876         the Netscape/Mozilla cookie file format (see `curl(1)`).
1877         NOTE that the file specified with http.cookieFile is used only as
1878         input unless http.saveCookies is set.
1880 http.saveCookies::
1881         If set, store cookies received during requests to the file specified by
1882         http.cookieFile. Has no effect if http.cookieFile is unset.
1884 http.sslVersion::
1885         The SSL version to use when negotiating an SSL connection, if you
1886         want to force the default.  The available and default version
1887         depend on whether libcurl was built against NSS or OpenSSL and the
1888         particular configuration of the crypto library in use. Internally
1889         this sets the 'CURLOPT_SSL_VERSION' option; see the libcurl
1890         documentation for more details on the format of this option and
1891         for the ssl version supported. Actually the possible values of
1892         this option are:
1894         - sslv2
1895         - sslv3
1896         - tlsv1
1897         - tlsv1.0
1898         - tlsv1.1
1899         - tlsv1.2
1902 Can be overridden by the `GIT_SSL_VERSION` environment variable.
1903 To force git to use libcurl's default ssl version and ignore any
1904 explicit http.sslversion option, set `GIT_SSL_VERSION` to the
1905 empty string.
1907 http.sslCipherList::
1908   A list of SSL ciphers to use when negotiating an SSL connection.
1909   The available ciphers depend on whether libcurl was built against
1910   NSS or OpenSSL and the particular configuration of the crypto
1911   library in use.  Internally this sets the 'CURLOPT_SSL_CIPHER_LIST'
1912   option; see the libcurl documentation for more details on the format
1913   of this list.
1915 Can be overridden by the `GIT_SSL_CIPHER_LIST` environment variable.
1916 To force git to use libcurl's default cipher list and ignore any
1917 explicit http.sslCipherList option, set `GIT_SSL_CIPHER_LIST` to the
1918 empty string.
1920 http.sslVerify::
1921         Whether to verify the SSL certificate when fetching or pushing
1922         over HTTPS. Can be overridden by the `GIT_SSL_NO_VERIFY` environment
1923         variable.
1925 http.sslCert::
1926         File containing the SSL certificate when fetching or pushing
1927         over HTTPS. Can be overridden by the `GIT_SSL_CERT` environment
1928         variable.
1930 http.sslKey::
1931         File containing the SSL private key when fetching or pushing
1932         over HTTPS. Can be overridden by the `GIT_SSL_KEY` environment
1933         variable.
1935 http.sslCertPasswordProtected::
1936         Enable Git's password prompt for the SSL certificate.  Otherwise
1937         OpenSSL will prompt the user, possibly many times, if the
1938         certificate or private key is encrypted.  Can be overridden by the
1939         `GIT_SSL_CERT_PASSWORD_PROTECTED` environment variable.
1941 http.sslCAInfo::
1942         File containing the certificates to verify the peer with when
1943         fetching or pushing over HTTPS. Can be overridden by the
1944         `GIT_SSL_CAINFO` environment variable.
1946 http.sslCAPath::
1947         Path containing files with the CA certificates to verify the peer
1948         with when fetching or pushing over HTTPS. Can be overridden
1949         by the `GIT_SSL_CAPATH` environment variable.
1951 http.pinnedpubkey::
1952         Public key of the https service. It may either be the filename of
1953         a PEM or DER encoded public key file or a string starting with
1954         'sha256//' followed by the base64 encoded sha256 hash of the
1955         public key. See also libcurl 'CURLOPT_PINNEDPUBLICKEY'. git will
1956         exit with an error if this option is set but not supported by
1957         cURL.
1959 http.sslTry::
1960         Attempt to use AUTH SSL/TLS and encrypted data transfers
1961         when connecting via regular FTP protocol. This might be needed
1962         if the FTP server requires it for security reasons or you wish
1963         to connect securely whenever remote FTP server supports it.
1964         Default is false since it might trigger certificate verification
1965         errors on misconfigured servers.
1967 http.maxRequests::
1968         How many HTTP requests to launch in parallel. Can be overridden
1969         by the `GIT_HTTP_MAX_REQUESTS` environment variable. Default is 5.
1971 http.minSessions::
1972         The number of curl sessions (counted across slots) to be kept across
1973         requests. They will not be ended with curl_easy_cleanup() until
1974         http_cleanup() is invoked. If USE_CURL_MULTI is not defined, this
1975         value will be capped at 1. Defaults to 1.
1977 http.postBuffer::
1978         Maximum size in bytes of the buffer used by smart HTTP
1979         transports when POSTing data to the remote system.
1980         For requests larger than this buffer size, HTTP/1.1 and
1981         Transfer-Encoding: chunked is used to avoid creating a
1982         massive pack file locally.  Default is 1 MiB, which is
1983         sufficient for most requests.
1985 http.lowSpeedLimit, http.lowSpeedTime::
1986         If the HTTP transfer speed is less than 'http.lowSpeedLimit'
1987         for longer than 'http.lowSpeedTime' seconds, the transfer is aborted.
1988         Can be overridden by the `GIT_HTTP_LOW_SPEED_LIMIT` and
1989         `GIT_HTTP_LOW_SPEED_TIME` environment variables.
1991 http.noEPSV::
1992         A boolean which disables using of EPSV ftp command by curl.
1993         This can helpful with some "poor" ftp servers which don't
1994         support EPSV mode. Can be overridden by the `GIT_CURL_FTP_NO_EPSV`
1995         environment variable. Default is false (curl will use EPSV).
1997 http.userAgent::
1998         The HTTP USER_AGENT string presented to an HTTP server.  The default
1999         value represents the version of the client Git such as git/1.7.1.
2000         This option allows you to override this value to a more common value
2001         such as Mozilla/4.0.  This may be necessary, for instance, if
2002         connecting through a firewall that restricts HTTP connections to a set
2003         of common USER_AGENT strings (but not including those like git/1.7.1).
2004         Can be overridden by the `GIT_HTTP_USER_AGENT` environment variable.
2006 http.followRedirects::
2007         Whether git should follow HTTP redirects. If set to `true`, git
2008         will transparently follow any redirect issued by a server it
2009         encounters. If set to `false`, git will treat all redirects as
2010         errors. If set to `initial`, git will follow redirects only for
2011         the initial request to a remote, but not for subsequent
2012         follow-up HTTP requests. Since git uses the redirected URL as
2013         the base for the follow-up requests, this is generally
2014         sufficient. The default is `initial`.
2016 http.<url>.*::
2017         Any of the http.* options above can be applied selectively to some URLs.
2018         For a config key to match a URL, each element of the config key is
2019         compared to that of the URL, in the following order:
2022 . Scheme (e.g., `https` in `https://example.com/`). This field
2023   must match exactly between the config key and the URL.
2025 . Host/domain name (e.g., `example.com` in `https://example.com/`).
2026   This field must match between the config key and the URL. It is
2027   possible to specify a `*` as part of the host name to match all subdomains
2028   at this level. `https://*.example.com/` for example would match
2029   `https://foo.example.com/`, but not `https://foo.bar.example.com/`.
2031 . Port number (e.g., `8080` in `http://example.com:8080/`).
2032   This field must match exactly between the config key and the URL.
2033   Omitted port numbers are automatically converted to the correct
2034   default for the scheme before matching.
2036 . Path (e.g., `repo.git` in `https://example.com/repo.git`). The
2037   path field of the config key must match the path field of the URL
2038   either exactly or as a prefix of slash-delimited path elements.  This means
2039   a config key with path `foo/` matches URL path `foo/bar`.  A prefix can only
2040   match on a slash (`/`) boundary.  Longer matches take precedence (so a config
2041   key with path `foo/bar` is a better match to URL path `foo/bar` than a config
2042   key with just path `foo/`).
2044 . User name (e.g., `user` in `https://user@example.com/repo.git`). If
2045   the config key has a user name it must match the user name in the
2046   URL exactly. If the config key does not have a user name, that
2047   config key will match a URL with any user name (including none),
2048   but at a lower precedence than a config key with a user name.
2051 The list above is ordered by decreasing precedence; a URL that matches
2052 a config key's path is preferred to one that matches its user name. For example,
2053 if the URL is `https://user@example.com/foo/bar` a config key match of
2054 `https://example.com/foo` will be preferred over a config key match of
2055 `https://user@example.com`.
2057 All URLs are normalized before attempting any matching (the password part,
2058 if embedded in the URL, is always ignored for matching purposes) so that
2059 equivalent URLs that are simply spelled differently will match properly.
2060 Environment variable settings always override any matches.  The URLs that are
2061 matched against are those given directly to Git commands.  This means any URLs
2062 visited as a result of a redirection do not participate in matching.
2064 ssh.variant::
2065         Depending on the value of the environment variables `GIT_SSH` or
2066         `GIT_SSH_COMMAND`, or the config setting `core.sshCommand`, Git
2067         auto-detects whether to adjust its command-line parameters for use
2068         with plink or tortoiseplink, as opposed to the default (OpenSSH).
2070 The config variable `ssh.variant` can be set to override this auto-detection;
2071 valid values are `ssh`, `plink`, `putty` or `tortoiseplink`. Any other value
2072 will be treated as normal ssh. This setting can be overridden via the
2073 environment variable `GIT_SSH_VARIANT`.
2075 i18n.commitEncoding::
2076         Character encoding the commit messages are stored in; Git itself
2077         does not care per se, but this information is necessary e.g. when
2078         importing commits from emails or in the gitk graphical history
2079         browser (and possibly at other places in the future or in other
2080         porcelains). See e.g. linkgit:git-mailinfo[1]. Defaults to 'utf-8'.
2082 i18n.logOutputEncoding::
2083         Character encoding the commit messages are converted to when
2084         running 'git log' and friends.
2086 imap::
2087         The configuration variables in the 'imap' section are described
2088         in linkgit:git-imap-send[1].
2090 index.version::
2091         Specify the version with which new index files should be
2092         initialized.  This does not affect existing repositories.
2094 init.templateDir::
2095         Specify the directory from which templates will be copied.
2096         (See the "TEMPLATE DIRECTORY" section of linkgit:git-init[1].)
2098 instaweb.browser::
2099         Specify the program that will be used to browse your working
2100         repository in gitweb. See linkgit:git-instaweb[1].
2102 instaweb.httpd::
2103         The HTTP daemon command-line to start gitweb on your working
2104         repository. See linkgit:git-instaweb[1].
2106 instaweb.local::
2107         If true the web server started by linkgit:git-instaweb[1] will
2108         be bound to the local IP (127.0.0.1).
2110 instaweb.modulePath::
2111         The default module path for linkgit:git-instaweb[1] to use
2112         instead of /usr/lib/apache2/modules.  Only used if httpd
2113         is Apache.
2115 instaweb.port::
2116         The port number to bind the gitweb httpd to. See
2117         linkgit:git-instaweb[1].
2119 interactive.singleKey::
2120         In interactive commands, allow the user to provide one-letter
2121         input with a single key (i.e., without hitting enter).
2122         Currently this is used by the `--patch` mode of
2123         linkgit:git-add[1], linkgit:git-checkout[1], linkgit:git-commit[1],
2124         linkgit:git-reset[1], and linkgit:git-stash[1]. Note that this
2125         setting is silently ignored if portable keystroke input
2126         is not available; requires the Perl module Term::ReadKey.
2128 interactive.diffFilter::
2129         When an interactive command (such as `git add --patch`) shows
2130         a colorized diff, git will pipe the diff through the shell
2131         command defined by this configuration variable. The command may
2132         mark up the diff further for human consumption, provided that it
2133         retains a one-to-one correspondence with the lines in the
2134         original diff. Defaults to disabled (no filtering).
2136 log.abbrevCommit::
2137         If true, makes linkgit:git-log[1], linkgit:git-show[1], and
2138         linkgit:git-whatchanged[1] assume `--abbrev-commit`. You may
2139         override this option with `--no-abbrev-commit`.
2141 log.date::
2142         Set the default date-time mode for the 'log' command.
2143         Setting a value for log.date is similar to using 'git log''s
2144         `--date` option.  See linkgit:git-log[1] for details.
2146 log.decorate::
2147         Print out the ref names of any commits that are shown by the log
2148         command. If 'short' is specified, the ref name prefixes 'refs/heads/',
2149         'refs/tags/' and 'refs/remotes/' will not be printed. If 'full' is
2150         specified, the full ref name (including prefix) will be printed.
2151         If 'auto' is specified, then if the output is going to a terminal,
2152         the ref names are shown as if 'short' were given, otherwise no ref
2153         names are shown. This is the same as the `--decorate` option
2154         of the `git log`.
2156 log.follow::
2157         If `true`, `git log` will act as if the `--follow` option was used when
2158         a single <path> is given.  This has the same limitations as `--follow`,
2159         i.e. it cannot be used to follow multiple files and does not work well
2160         on non-linear history.
2162 log.graphColors::
2163         A list of colors, separated by commas, that can be used to draw
2164         history lines in `git log --graph`.
2166 log.showRoot::
2167         If true, the initial commit will be shown as a big creation event.
2168         This is equivalent to a diff against an empty tree.
2169         Tools like linkgit:git-log[1] or linkgit:git-whatchanged[1], which
2170         normally hide the root commit will now show it. True by default.
2172 log.showSignature::
2173         If true, makes linkgit:git-log[1], linkgit:git-show[1], and
2174         linkgit:git-whatchanged[1] assume `--show-signature`.
2176 log.mailmap::
2177         If true, makes linkgit:git-log[1], linkgit:git-show[1], and
2178         linkgit:git-whatchanged[1] assume `--use-mailmap`.
2180 mailinfo.scissors::
2181         If true, makes linkgit:git-mailinfo[1] (and therefore
2182         linkgit:git-am[1]) act by default as if the --scissors option
2183         was provided on the command-line. When active, this features
2184         removes everything from the message body before a scissors
2185         line (i.e. consisting mainly of ">8", "8<" and "-").
2187 mailmap.file::
2188         The location of an augmenting mailmap file. The default
2189         mailmap, located in the root of the repository, is loaded
2190         first, then the mailmap file pointed to by this variable.
2191         The location of the mailmap file may be in a repository
2192         subdirectory, or somewhere outside of the repository itself.
2193         See linkgit:git-shortlog[1] and linkgit:git-blame[1].
2195 mailmap.blob::
2196         Like `mailmap.file`, but consider the value as a reference to a
2197         blob in the repository. If both `mailmap.file` and
2198         `mailmap.blob` are given, both are parsed, with entries from
2199         `mailmap.file` taking precedence. In a bare repository, this
2200         defaults to `HEAD:.mailmap`. In a non-bare repository, it
2201         defaults to empty.
2203 man.viewer::
2204         Specify the programs that may be used to display help in the
2205         'man' format. See linkgit:git-help[1].
2207 man.<tool>.cmd::
2208         Specify the command to invoke the specified man viewer. The
2209         specified command is evaluated in shell with the man page
2210         passed as argument. (See linkgit:git-help[1].)
2212 man.<tool>.path::
2213         Override the path for the given tool that may be used to
2214         display help in the 'man' format. See linkgit:git-help[1].
2216 include::merge-config.txt[]
2218 mergetool.<tool>.path::
2219         Override the path for the given tool.  This is useful in case
2220         your tool is not in the PATH.
2222 mergetool.<tool>.cmd::
2223         Specify the command to invoke the specified merge tool.  The
2224         specified command is evaluated in shell with the following
2225         variables available: 'BASE' is the name of a temporary file
2226         containing the common base of the files to be merged, if available;
2227         'LOCAL' is the name of a temporary file containing the contents of
2228         the file on the current branch; 'REMOTE' is the name of a temporary
2229         file containing the contents of the file from the branch being
2230         merged; 'MERGED' contains the name of the file to which the merge
2231         tool should write the results of a successful merge.
2233 mergetool.<tool>.trustExitCode::
2234         For a custom merge command, specify whether the exit code of
2235         the merge command can be used to determine whether the merge was
2236         successful.  If this is not set to true then the merge target file
2237         timestamp is checked and the merge assumed to have been successful
2238         if the file has been updated, otherwise the user is prompted to
2239         indicate the success of the merge.
2241 mergetool.meld.hasOutput::
2242         Older versions of `meld` do not support the `--output` option.
2243         Git will attempt to detect whether `meld` supports `--output`
2244         by inspecting the output of `meld --help`.  Configuring
2245         `mergetool.meld.hasOutput` will make Git skip these checks and
2246         use the configured value instead.  Setting `mergetool.meld.hasOutput`
2247         to `true` tells Git to unconditionally use the `--output` option,
2248         and `false` avoids using `--output`.
2250 mergetool.keepBackup::
2251         After performing a merge, the original file with conflict markers
2252         can be saved as a file with a `.orig` extension.  If this variable
2253         is set to `false` then this file is not preserved.  Defaults to
2254         `true` (i.e. keep the backup files).
2256 mergetool.keepTemporaries::
2257         When invoking a custom merge tool, Git uses a set of temporary
2258         files to pass to the tool. If the tool returns an error and this
2259         variable is set to `true`, then these temporary files will be
2260         preserved, otherwise they will be removed after the tool has
2261         exited. Defaults to `false`.
2263 mergetool.writeToTemp::
2264         Git writes temporary 'BASE', 'LOCAL', and 'REMOTE' versions of
2265         conflicting files in the worktree by default.  Git will attempt
2266         to use a temporary directory for these files when set `true`.
2267         Defaults to `false`.
2269 mergetool.prompt::
2270         Prompt before each invocation of the merge resolution program.
2272 notes.mergeStrategy::
2273         Which merge strategy to choose by default when resolving notes
2274         conflicts.  Must be one of `manual`, `ours`, `theirs`, `union`, or
2275         `cat_sort_uniq`.  Defaults to `manual`.  See "NOTES MERGE STRATEGIES"
2276         section of linkgit:git-notes[1] for more information on each strategy.
2278 notes.<name>.mergeStrategy::
2279         Which merge strategy to choose when doing a notes merge into
2280         refs/notes/<name>.  This overrides the more general
2281         "notes.mergeStrategy".  See the "NOTES MERGE STRATEGIES" section in
2282         linkgit:git-notes[1] for more information on the available strategies.
2284 notes.displayRef::
2285         The (fully qualified) refname from which to show notes when
2286         showing commit messages.  The value of this variable can be set
2287         to a glob, in which case notes from all matching refs will be
2288         shown.  You may also specify this configuration variable
2289         several times.  A warning will be issued for refs that do not
2290         exist, but a glob that does not match any refs is silently
2291         ignored.
2293 This setting can be overridden with the `GIT_NOTES_DISPLAY_REF`
2294 environment variable, which must be a colon separated list of refs or
2295 globs.
2297 The effective value of "core.notesRef" (possibly overridden by
2298 GIT_NOTES_REF) is also implicitly added to the list of refs to be
2299 displayed.
2301 notes.rewrite.<command>::
2302         When rewriting commits with <command> (currently `amend` or
2303         `rebase`) and this variable is set to `true`, Git
2304         automatically copies your notes from the original to the
2305         rewritten commit.  Defaults to `true`, but see
2306         "notes.rewriteRef" below.
2308 notes.rewriteMode::
2309         When copying notes during a rewrite (see the
2310         "notes.rewrite.<command>" option), determines what to do if
2311         the target commit already has a note.  Must be one of
2312         `overwrite`, `concatenate`, `cat_sort_uniq`, or `ignore`.
2313         Defaults to `concatenate`.
2315 This setting can be overridden with the `GIT_NOTES_REWRITE_MODE`
2316 environment variable.
2318 notes.rewriteRef::
2319         When copying notes during a rewrite, specifies the (fully
2320         qualified) ref whose notes should be copied.  The ref may be a
2321         glob, in which case notes in all matching refs will be copied.
2322         You may also specify this configuration several times.
2324 Does not have a default value; you must configure this variable to
2325 enable note rewriting.  Set it to `refs/notes/commits` to enable
2326 rewriting for the default commit notes.
2328 This setting can be overridden with the `GIT_NOTES_REWRITE_REF`
2329 environment variable, which must be a colon separated list of refs or
2330 globs.
2332 pack.window::
2333         The size of the window used by linkgit:git-pack-objects[1] when no
2334         window size is given on the command line. Defaults to 10.
2336 pack.depth::
2337         The maximum delta depth used by linkgit:git-pack-objects[1] when no
2338         maximum depth is given on the command line. Defaults to 50.
2340 pack.windowMemory::
2341         The maximum size of memory that is consumed by each thread
2342         in linkgit:git-pack-objects[1] for pack window memory when
2343         no limit is given on the command line.  The value can be
2344         suffixed with "k", "m", or "g".  When left unconfigured (or
2345         set explicitly to 0), there will be no limit.
2347 pack.compression::
2348         An integer -1..9, indicating the compression level for objects
2349         in a pack file. -1 is the zlib default. 0 means no
2350         compression, and 1..9 are various speed/size tradeoffs, 9 being
2351         slowest.  If not set,  defaults to core.compression.  If that is
2352         not set,  defaults to -1, the zlib default, which is "a default
2353         compromise between speed and compression (currently equivalent
2354         to level 6)."
2356 Note that changing the compression level will not automatically recompress
2357 all existing objects. You can force recompression by passing the -F option
2358 to linkgit:git-repack[1].
2360 pack.deltaCacheSize::
2361         The maximum memory in bytes used for caching deltas in
2362         linkgit:git-pack-objects[1] before writing them out to a pack.
2363         This cache is used to speed up the writing object phase by not
2364         having to recompute the final delta result once the best match
2365         for all objects is found.  Repacking large repositories on machines
2366         which are tight with memory might be badly impacted by this though,
2367         especially if this cache pushes the system into swapping.
2368         A value of 0 means no limit. The smallest size of 1 byte may be
2369         used to virtually disable this cache. Defaults to 256 MiB.
2371 pack.deltaCacheLimit::
2372         The maximum size of a delta, that is cached in
2373         linkgit:git-pack-objects[1]. This cache is used to speed up the
2374         writing object phase by not having to recompute the final delta
2375         result once the best match for all objects is found. Defaults to 1000.
2377 pack.threads::
2378         Specifies the number of threads to spawn when searching for best
2379         delta matches.  This requires that linkgit:git-pack-objects[1]
2380         be compiled with pthreads otherwise this option is ignored with a
2381         warning. This is meant to reduce packing time on multiprocessor
2382         machines. The required amount of memory for the delta search window
2383         is however multiplied by the number of threads.
2384         Specifying 0 will cause Git to auto-detect the number of CPU's
2385         and set the number of threads accordingly.
2387 pack.indexVersion::
2388         Specify the default pack index version.  Valid values are 1 for
2389         legacy pack index used by Git versions prior to 1.5.2, and 2 for
2390         the new pack index with capabilities for packs larger than 4 GB
2391         as well as proper protection against the repacking of corrupted
2392         packs.  Version 2 is the default.  Note that version 2 is enforced
2393         and this config option ignored whenever the corresponding pack is
2394         larger than 2 GB.
2396 If you have an old Git that does not understand the version 2 `*.idx` file,
2397 cloning or fetching over a non native protocol (e.g. "http")
2398 that will copy both `*.pack` file and corresponding `*.idx` file from the
2399 other side may give you a repository that cannot be accessed with your
2400 older version of Git. If the `*.pack` file is smaller than 2 GB, however,
2401 you can use linkgit:git-index-pack[1] on the *.pack file to regenerate
2402 the `*.idx` file.
2404 pack.packSizeLimit::
2405         The maximum size of a pack.  This setting only affects
2406         packing to a file when repacking, i.e. the git:// protocol
2407         is unaffected.  It can be overridden by the `--max-pack-size`
2408         option of linkgit:git-repack[1].  Reaching this limit results
2409         in the creation of multiple packfiles; which in turn prevents
2410         bitmaps from being created.
2411         The minimum size allowed is limited to 1 MiB.
2412         The default is unlimited.
2413         Common unit suffixes of 'k', 'm', or 'g' are
2414         supported.
2416 pack.useBitmaps::
2417         When true, git will use pack bitmaps (if available) when packing
2418         to stdout (e.g., during the server side of a fetch). Defaults to
2419         true. You should not generally need to turn this off unless
2420         you are debugging pack bitmaps.
2422 pack.writeBitmaps (deprecated)::
2423         This is a deprecated synonym for `repack.writeBitmaps`.
2425 pack.writeBitmapHashCache::
2426         When true, git will include a "hash cache" section in the bitmap
2427         index (if one is written). This cache can be used to feed git's
2428         delta heuristics, potentially leading to better deltas between
2429         bitmapped and non-bitmapped objects (e.g., when serving a fetch
2430         between an older, bitmapped pack and objects that have been
2431         pushed since the last gc). The downside is that it consumes 4
2432         bytes per object of disk space, and that JGit's bitmap
2433         implementation does not understand it, causing it to complain if
2434         Git and JGit are used on the same repository. Defaults to false.
2436 pager.<cmd>::
2437         If the value is boolean, turns on or off pagination of the
2438         output of a particular Git subcommand when writing to a tty.
2439         Otherwise, turns on pagination for the subcommand using the
2440         pager specified by the value of `pager.<cmd>`.  If `--paginate`
2441         or `--no-pager` is specified on the command line, it takes
2442         precedence over this option.  To disable pagination for all
2443         commands, set `core.pager` or `GIT_PAGER` to `cat`.
2445 pretty.<name>::
2446         Alias for a --pretty= format string, as specified in
2447         linkgit:git-log[1]. Any aliases defined here can be used just
2448         as the built-in pretty formats could. For example,
2449         running `git config pretty.changelog "format:* %H %s"`
2450         would cause the invocation `git log --pretty=changelog`
2451         to be equivalent to running `git log "--pretty=format:* %H %s"`.
2452         Note that an alias with the same name as a built-in format
2453         will be silently ignored.
2455 protocol.allow::
2456         If set, provide a user defined default policy for all protocols which
2457         don't explicitly have a policy (`protocol.<name>.allow`).  By default,
2458         if unset, known-safe protocols (http, https, git, ssh, file) have a
2459         default policy of `always`, known-dangerous protocols (ext) have a
2460         default policy of `never`, and all other protocols have a default
2461         policy of `user`.  Supported policies:
2465 * `always` - protocol is always able to be used.
2467 * `never` - protocol is never able to be used.
2469 * `user` - protocol is only able to be used when `GIT_PROTOCOL_FROM_USER` is
2470   either unset or has a value of 1.  This policy should be used when you want a
2471   protocol to be directly usable by the user but don't want it used by commands which
2472   execute clone/fetch/push commands without user input, e.g. recursive
2473   submodule initialization.
2477 protocol.<name>.allow::
2478         Set a policy to be used by protocol `<name>` with clone/fetch/push
2479         commands. See `protocol.allow` above for the available policies.
2481 The protocol names currently used by git are:
2484   - `file`: any local file-based path (including `file://` URLs,
2485     or local paths)
2487   - `git`: the anonymous git protocol over a direct TCP
2488     connection (or proxy, if configured)
2490   - `ssh`: git over ssh (including `host:path` syntax,
2491     `ssh://`, etc).
2493   - `http`: git over http, both "smart http" and "dumb http".
2494     Note that this does _not_ include `https`; if you want to configure
2495     both, you must do so individually.
2497   - any external helpers are named by their protocol (e.g., use
2498     `hg` to allow the `git-remote-hg` helper)
2501 pull.ff::
2502         By default, Git does not create an extra merge commit when merging
2503         a commit that is a descendant of the current commit. Instead, the
2504         tip of the current branch is fast-forwarded. When set to `false`,
2505         this variable tells Git to create an extra merge commit in such
2506         a case (equivalent to giving the `--no-ff` option from the command
2507         line). When set to `only`, only such fast-forward merges are
2508         allowed (equivalent to giving the `--ff-only` option from the
2509         command line). This setting overrides `merge.ff` when pulling.
2511 pull.rebase::
2512         When true, rebase branches on top of the fetched branch, instead
2513         of merging the default branch from the default remote when "git
2514         pull" is run. See "branch.<name>.rebase" for setting this on a
2515         per-branch basis.
2517 When preserve, also pass `--preserve-merges` along to 'git rebase'
2518 so that locally committed merge commits will not be flattened
2519 by running 'git pull'.
2521 When the value is `interactive`, the rebase is run in interactive mode.
2523 *NOTE*: this is a possibly dangerous operation; do *not* use
2524 it unless you understand the implications (see linkgit:git-rebase[1]
2525 for details).
2527 pull.octopus::
2528         The default merge strategy to use when pulling multiple branches
2529         at once.
2531 pull.twohead::
2532         The default merge strategy to use when pulling a single branch.
2534 push.default::
2535         Defines the action `git push` should take if no refspec is
2536         explicitly given.  Different values are well-suited for
2537         specific workflows; for instance, in a purely central workflow
2538         (i.e. the fetch source is equal to the push destination),
2539         `upstream` is probably what you want.  Possible values are:
2543 * `nothing` - do not push anything (error out) unless a refspec is
2544   explicitly given. This is primarily meant for people who want to
2545   avoid mistakes by always being explicit.
2547 * `current` - push the current branch to update a branch with the same
2548   name on the receiving end.  Works in both central and non-central
2549   workflows.
2551 * `upstream` - push the current branch back to the branch whose
2552   changes are usually integrated into the current branch (which is
2553   called `@{upstream}`).  This mode only makes sense if you are
2554   pushing to the same repository you would normally pull from
2555   (i.e. central workflow).
2557 * `tracking` - This is a deprecated synonym for `upstream`.
2559 * `simple` - in centralized workflow, work like `upstream` with an
2560   added safety to refuse to push if the upstream branch's name is
2561   different from the local one.
2563 When pushing to a remote that is different from the remote you normally
2564 pull from, work as `current`.  This is the safest option and is suited
2565 for beginners.
2567 This mode has become the default in Git 2.0.
2569 * `matching` - push all branches having the same name on both ends.
2570   This makes the repository you are pushing to remember the set of
2571   branches that will be pushed out (e.g. if you always push 'maint'
2572   and 'master' there and no other branches, the repository you push
2573   to will have these two branches, and your local 'maint' and
2574   'master' will be pushed there).
2576 To use this mode effectively, you have to make sure _all_ the
2577 branches you would push out are ready to be pushed out before
2578 running 'git push', as the whole point of this mode is to allow you
2579 to push all of the branches in one go.  If you usually finish work
2580 on only one branch and push out the result, while other branches are
2581 unfinished, this mode is not for you.  Also this mode is not
2582 suitable for pushing into a shared central repository, as other
2583 people may add new branches there, or update the tip of existing
2584 branches outside your control.
2586 This used to be the default, but not since Git 2.0 (`simple` is the
2587 new default).
2591 push.followTags::
2592         If set to true enable `--follow-tags` option by default.  You
2593         may override this configuration at time of push by specifying
2594         `--no-follow-tags`.
2596 push.gpgSign::
2597         May be set to a boolean value, or the string 'if-asked'. A true
2598         value causes all pushes to be GPG signed, as if `--signed` is
2599         passed to linkgit:git-push[1]. The string 'if-asked' causes
2600         pushes to be signed if the server supports it, as if
2601         `--signed=if-asked` is passed to 'git push'. A false value may
2602         override a value from a lower-priority config file. An explicit
2603         command-line flag always overrides this config option.
2605 push.recurseSubmodules::
2606         Make sure all submodule commits used by the revisions to be pushed
2607         are available on a remote-tracking branch. If the value is 'check'
2608         then Git will verify that all submodule commits that changed in the
2609         revisions to be pushed are available on at least one remote of the
2610         submodule. If any commits are missing, the push will be aborted and
2611         exit with non-zero status. If the value is 'on-demand' then all
2612         submodules that changed in the revisions to be pushed will be
2613         pushed. If on-demand was not able to push all necessary revisions
2614         it will also be aborted and exit with non-zero status. If the value
2615         is 'no' then default behavior of ignoring submodules when pushing
2616         is retained. You may override this configuration at time of push by
2617         specifying '--recurse-submodules=check|on-demand|no'.
2619 rebase.stat::
2620         Whether to show a diffstat of what changed upstream since the last
2621         rebase. False by default.
2623 rebase.autoSquash::
2624         If set to true enable `--autosquash` option by default.
2626 rebase.autoStash::
2627         When set to true, automatically create a temporary stash entry
2628         before the operation begins, and apply it after the operation
2629         ends.  This means that you can run rebase on a dirty worktree.
2630         However, use with care: the final stash application after a
2631         successful rebase might result in non-trivial conflicts.
2632         Defaults to false.
2634 rebase.missingCommitsCheck::
2635         If set to "warn", git rebase -i will print a warning if some
2636         commits are removed (e.g. a line was deleted), however the
2637         rebase will still proceed. If set to "error", it will print
2638         the previous warning and stop the rebase, 'git rebase
2639         --edit-todo' can then be used to correct the error. If set to
2640         "ignore", no checking is done.
2641         To drop a commit without warning or error, use the `drop`
2642         command in the todo-list.
2643         Defaults to "ignore".
2645 rebase.instructionFormat::
2646         A format string, as specified in linkgit:git-log[1], to be used for
2647         the instruction list during an interactive rebase.  The format will automatically
2648         have the long commit hash prepended to the format.
2650 receive.advertiseAtomic::
2651         By default, git-receive-pack will advertise the atomic push
2652         capability to its clients. If you don't want to advertise this
2653         capability, set this variable to false.
2655 receive.advertisePushOptions::
2656         When set to true, git-receive-pack will advertise the push options
2657         capability to its clients. False by default.
2659 receive.autogc::
2660         By default, git-receive-pack will run "git-gc --auto" after
2661         receiving data from git-push and updating refs.  You can stop
2662         it by setting this variable to false.
2664 receive.certNonceSeed::
2665         By setting this variable to a string, `git receive-pack`
2666         will accept a `git push --signed` and verifies it by using
2667         a "nonce" protected by HMAC using this string as a secret
2668         key.
2670 receive.certNonceSlop::
2671         When a `git push --signed` sent a push certificate with a
2672         "nonce" that was issued by a receive-pack serving the same
2673         repository within this many seconds, export the "nonce"
2674         found in the certificate to `GIT_PUSH_CERT_NONCE` to the
2675         hooks (instead of what the receive-pack asked the sending
2676         side to include).  This may allow writing checks in
2677         `pre-receive` and `post-receive` a bit easier.  Instead of
2678         checking `GIT_PUSH_CERT_NONCE_SLOP` environment variable
2679         that records by how many seconds the nonce is stale to
2680         decide if they want to accept the certificate, they only
2681         can check `GIT_PUSH_CERT_NONCE_STATUS` is `OK`.
2683 receive.fsckObjects::
2684         If it is set to true, git-receive-pack will check all received
2685         objects. It will abort in the case of a malformed object or a
2686         broken link. The result of an abort are only dangling objects.
2687         Defaults to false. If not set, the value of `transfer.fsckObjects`
2688         is used instead.
2690 receive.fsck.<msg-id>::
2691         When `receive.fsckObjects` is set to true, errors can be switched
2692         to warnings and vice versa by configuring the `receive.fsck.<msg-id>`
2693         setting where the `<msg-id>` is the fsck message ID and the value
2694         is one of `error`, `warn` or `ignore`. For convenience, fsck prefixes
2695         the error/warning with the message ID, e.g. "missingEmail: invalid
2696         author/committer line - missing email" means that setting
2697         `receive.fsck.missingEmail = ignore` will hide that issue.
2699 This feature is intended to support working with legacy repositories
2700 which would not pass pushing when `receive.fsckObjects = true`, allowing
2701 the host to accept repositories with certain known issues but still catch
2702 other issues.
2704 receive.fsck.skipList::
2705         The path to a sorted list of object names (i.e. one SHA-1 per
2706         line) that are known to be broken in a non-fatal way and should
2707         be ignored. This feature is useful when an established project
2708         should be accepted despite early commits containing errors that
2709         can be safely ignored such as invalid committer email addresses.
2710         Note: corrupt objects cannot be skipped with this setting.
2712 receive.keepAlive::
2713         After receiving the pack from the client, `receive-pack` may
2714         produce no output (if `--quiet` was specified) while processing
2715         the pack, causing some networks to drop the TCP connection.
2716         With this option set, if `receive-pack` does not transmit
2717         any data in this phase for `receive.keepAlive` seconds, it will
2718         send a short keepalive packet.  The default is 5 seconds; set
2719         to 0 to disable keepalives entirely.
2721 receive.unpackLimit::
2722         If the number of objects received in a push is below this
2723         limit then the objects will be unpacked into loose object
2724         files. However if the number of received objects equals or
2725         exceeds this limit then the received pack will be stored as
2726         a pack, after adding any missing delta bases.  Storing the
2727         pack from a push can make the push operation complete faster,
2728         especially on slow filesystems.  If not set, the value of
2729         `transfer.unpackLimit` is used instead.
2731 receive.maxInputSize::
2732         If the size of the incoming pack stream is larger than this
2733         limit, then git-receive-pack will error out, instead of
2734         accepting the pack file. If not set or set to 0, then the size
2735         is unlimited.
2737 receive.denyDeletes::
2738         If set to true, git-receive-pack will deny a ref update that deletes
2739         the ref. Use this to prevent such a ref deletion via a push.
2741 receive.denyDeleteCurrent::
2742         If set to true, git-receive-pack will deny a ref update that
2743         deletes the currently checked out branch of a non-bare repository.
2745 receive.denyCurrentBranch::
2746         If set to true or "refuse", git-receive-pack will deny a ref update
2747         to the currently checked out branch of a non-bare repository.
2748         Such a push is potentially dangerous because it brings the HEAD
2749         out of sync with the index and working tree. If set to "warn",
2750         print a warning of such a push to stderr, but allow the push to
2751         proceed. If set to false or "ignore", allow such pushes with no
2752         message. Defaults to "refuse".
2754 Another option is "updateInstead" which will update the working
2755 tree if pushing into the current branch.  This option is
2756 intended for synchronizing working directories when one side is not easily
2757 accessible via interactive ssh (e.g. a live web site, hence the requirement
2758 that the working directory be clean). This mode also comes in handy when
2759 developing inside a VM to test and fix code on different Operating Systems.
2761 By default, "updateInstead" will refuse the push if the working tree or
2762 the index have any difference from the HEAD, but the `push-to-checkout`
2763 hook can be used to customize this.  See linkgit:githooks[5].
2765 receive.denyNonFastForwards::
2766         If set to true, git-receive-pack will deny a ref update which is
2767         not a fast-forward. Use this to prevent such an update via a push,
2768         even if that push is forced. This configuration variable is
2769         set when initializing a shared repository.
2771 receive.hideRefs::
2772         This variable is the same as `transfer.hideRefs`, but applies
2773         only to `receive-pack` (and so affects pushes, but not fetches).
2774         An attempt to update or delete a hidden ref by `git push` is
2775         rejected.
2777 receive.updateServerInfo::
2778         If set to true, git-receive-pack will run git-update-server-info
2779         after receiving data from git-push and updating refs.
2781 receive.shallowUpdate::
2782         If set to true, .git/shallow can be updated when new refs
2783         require new shallow roots. Otherwise those refs are rejected.
2785 remote.pushDefault::
2786         The remote to push to by default.  Overrides
2787         `branch.<name>.remote` for all branches, and is overridden by
2788         `branch.<name>.pushRemote` for specific branches.
2790 remote.<name>.url::
2791         The URL of a remote repository.  See linkgit:git-fetch[1] or
2792         linkgit:git-push[1].
2794 remote.<name>.pushurl::
2795         The push URL of a remote repository.  See linkgit:git-push[1].
2797 remote.<name>.proxy::
2798         For remotes that require curl (http, https and ftp), the URL to
2799         the proxy to use for that remote.  Set to the empty string to
2800         disable proxying for that remote.
2802 remote.<name>.proxyAuthMethod::
2803         For remotes that require curl (http, https and ftp), the method to use for
2804         authenticating against the proxy in use (probably set in
2805         `remote.<name>.proxy`). See `http.proxyAuthMethod`.
2807 remote.<name>.fetch::
2808         The default set of "refspec" for linkgit:git-fetch[1]. See
2809         linkgit:git-fetch[1].
2811 remote.<name>.push::
2812         The default set of "refspec" for linkgit:git-push[1]. See
2813         linkgit:git-push[1].
2815 remote.<name>.mirror::
2816         If true, pushing to this remote will automatically behave
2817         as if the `--mirror` option was given on the command line.
2819 remote.<name>.skipDefaultUpdate::
2820         If true, this remote will be skipped by default when updating
2821         using linkgit:git-fetch[1] or the `update` subcommand of
2822         linkgit:git-remote[1].
2824 remote.<name>.skipFetchAll::
2825         If true, this remote will be skipped by default when updating
2826         using linkgit:git-fetch[1] or the `update` subcommand of
2827         linkgit:git-remote[1].
2829 remote.<name>.receivepack::
2830         The default program to execute on the remote side when pushing.  See
2831         option --receive-pack of linkgit:git-push[1].
2833 remote.<name>.uploadpack::
2834         The default program to execute on the remote side when fetching.  See
2835         option --upload-pack of linkgit:git-fetch-pack[1].
2837 remote.<name>.tagOpt::
2838         Setting this value to --no-tags disables automatic tag following when
2839         fetching from remote <name>. Setting it to --tags will fetch every
2840         tag from remote <name>, even if they are not reachable from remote
2841         branch heads. Passing these flags directly to linkgit:git-fetch[1] can
2842         override this setting. See options --tags and --no-tags of
2843         linkgit:git-fetch[1].
2845 remote.<name>.vcs::
2846         Setting this to a value <vcs> will cause Git to interact with
2847         the remote with the git-remote-<vcs> helper.
2849 remote.<name>.prune::
2850         When set to true, fetching from this remote by default will also
2851         remove any remote-tracking references that no longer exist on the
2852         remote (as if the `--prune` option was given on the command line).
2853         Overrides `fetch.prune` settings, if any.
2855 remotes.<group>::
2856         The list of remotes which are fetched by "git remote update
2857         <group>".  See linkgit:git-remote[1].
2859 repack.useDeltaBaseOffset::
2860         By default, linkgit:git-repack[1] creates packs that use
2861         delta-base offset. If you need to share your repository with
2862         Git older than version 1.4.4, either directly or via a dumb
2863         protocol such as http, then you need to set this option to
2864         "false" and repack. Access from old Git versions over the
2865         native protocol are unaffected by this option.
2867 repack.packKeptObjects::
2868         If set to true, makes `git repack` act as if
2869         `--pack-kept-objects` was passed. See linkgit:git-repack[1] for
2870         details. Defaults to `false` normally, but `true` if a bitmap
2871         index is being written (either via `--write-bitmap-index` or
2872         `repack.writeBitmaps`).
2874 repack.writeBitmaps::
2875         When true, git will write a bitmap index when packing all
2876         objects to disk (e.g., when `git repack -a` is run).  This
2877         index can speed up the "counting objects" phase of subsequent
2878         packs created for clones and fetches, at the cost of some disk
2879         space and extra time spent on the initial repack.  This has
2880         no effect if multiple packfiles are created.
2881         Defaults to false.
2883 rerere.autoUpdate::
2884         When set to true, `git-rerere` updates the index with the
2885         resulting contents after it cleanly resolves conflicts using
2886         previously recorded resolution.  Defaults to false.
2888 rerere.enabled::
2889         Activate recording of resolved conflicts, so that identical
2890         conflict hunks can be resolved automatically, should they be
2891         encountered again.  By default, linkgit:git-rerere[1] is
2892         enabled if there is an `rr-cache` directory under the
2893         `$GIT_DIR`, e.g. if "rerere" was previously used in the
2894         repository.
2896 sendemail.identity::
2897         A configuration identity. When given, causes values in the
2898         'sendemail.<identity>' subsection to take precedence over
2899         values in the 'sendemail' section. The default identity is
2900         the value of `sendemail.identity`.
2902 sendemail.smtpEncryption::
2903         See linkgit:git-send-email[1] for description.  Note that this
2904         setting is not subject to the 'identity' mechanism.
2906 sendemail.smtpssl (deprecated)::
2907         Deprecated alias for 'sendemail.smtpEncryption = ssl'.
2909 sendemail.smtpsslcertpath::
2910         Path to ca-certificates (either a directory or a single file).
2911         Set it to an empty string to disable certificate verification.
2913 sendemail.<identity>.*::
2914         Identity-specific versions of the 'sendemail.*' parameters
2915         found below, taking precedence over those when this
2916         identity is selected, through either the command-line or
2917         `sendemail.identity`.
2919 sendemail.aliasesFile::
2920 sendemail.aliasFileType::
2921 sendemail.annotate::
2922 sendemail.bcc::
2923 sendemail.cc::
2924 sendemail.ccCmd::
2925 sendemail.chainReplyTo::
2926 sendemail.confirm::
2927 sendemail.envelopeSender::
2928 sendemail.from::
2929 sendemail.multiEdit::
2930 sendemail.signedoffbycc::
2931 sendemail.smtpPass::
2932 sendemail.suppresscc::
2933 sendemail.suppressFrom::
2934 sendemail.to::
2935 sendemail.smtpDomain::
2936 sendemail.smtpServer::
2937 sendemail.smtpServerPort::
2938 sendemail.smtpServerOption::
2939 sendemail.smtpUser::
2940 sendemail.thread::
2941 sendemail.transferEncoding::
2942 sendemail.validate::
2943 sendemail.xmailer::
2944         See linkgit:git-send-email[1] for description.
2946 sendemail.signedoffcc (deprecated)::
2947         Deprecated alias for `sendemail.signedoffbycc`.
2949 sendemail.smtpBatchSize::
2950         Number of messages to be sent per connection, after that a relogin
2951         will happen.  If the value is 0 or undefined, send all messages in
2952         one connection.
2953         See also the `--batch-size` option of linkgit:git-send-email[1].
2955 sendemail.smtpReloginDelay::
2956         Seconds wait before reconnecting to smtp server.
2957         See also the `--relogin-delay` option of linkgit:git-send-email[1].
2959 showbranch.default::
2960         The default set of branches for linkgit:git-show-branch[1].
2961         See linkgit:git-show-branch[1].
2963 splitIndex.maxPercentChange::
2964         When the split index feature is used, this specifies the
2965         percent of entries the split index can contain compared to the
2966         total number of entries in both the split index and the shared
2967         index before a new shared index is written.
2968         The value should be between 0 and 100. If the value is 0 then
2969         a new shared index is always written, if it is 100 a new
2970         shared index is never written.
2971         By default the value is 20, so a new shared index is written
2972         if the number of entries in the split index would be greater
2973         than 20 percent of the total number of entries.
2974         See linkgit:git-update-index[1].
2976 splitIndex.sharedIndexExpire::
2977         When the split index feature is used, shared index files that
2978         were not modified since the time this variable specifies will
2979         be removed when a new shared index file is created. The value
2980         "now" expires all entries immediately, and "never" suppresses
2981         expiration altogether.
2982         The default value is "2.weeks.ago".
2983         Note that a shared index file is considered modified (for the
2984         purpose of expiration) each time a new split-index file is
2985         either created based on it or read from it.
2986         See linkgit:git-update-index[1].
2988 status.relativePaths::
2989         By default, linkgit:git-status[1] shows paths relative to the
2990         current directory. Setting this variable to `false` shows paths
2991         relative to the repository root (this was the default for Git
2992         prior to v1.5.4).
2994 status.short::
2995         Set to true to enable --short by default in linkgit:git-status[1].
2996         The option --no-short takes precedence over this variable.
2998 status.branch::
2999         Set to true to enable --branch by default in linkgit:git-status[1].
3000         The option --no-branch takes precedence over this variable.
3002 status.displayCommentPrefix::
3003         If set to true, linkgit:git-status[1] will insert a comment
3004         prefix before each output line (starting with
3005         `core.commentChar`, i.e. `#` by default). This was the
3006         behavior of linkgit:git-status[1] in Git 1.8.4 and previous.
3007         Defaults to false.
3009 status.showStash::
3010         If set to true, linkgit:git-status[1] will display the number of
3011         entries currently stashed away.
3012         Defaults to false.
3014 status.showUntrackedFiles::
3015         By default, linkgit:git-status[1] and linkgit:git-commit[1] show
3016         files which are not currently tracked by Git. Directories which
3017         contain only untracked files, are shown with the directory name
3018         only. Showing untracked files means that Git needs to lstat() all
3019         the files in the whole repository, which might be slow on some
3020         systems. So, this variable controls how the commands displays
3021         the untracked files. Possible values are:
3024 * `no` - Show no untracked files.
3025 * `normal` - Show untracked files and directories.
3026 * `all` - Show also individual files in untracked directories.
3029 If this variable is not specified, it defaults to 'normal'.
3030 This variable can be overridden with the -u|--untracked-files option
3031 of linkgit:git-status[1] and linkgit:git-commit[1].
3033 status.submoduleSummary::
3034         Defaults to false.
3035         If this is set to a non zero number or true (identical to -1 or an
3036         unlimited number), the submodule summary will be enabled and a
3037         summary of commits for modified submodules will be shown (see
3038         --summary-limit option of linkgit:git-submodule[1]). Please note
3039         that the summary output command will be suppressed for all
3040         submodules when `diff.ignoreSubmodules` is set to 'all' or only
3041         for those submodules where `submodule.<name>.ignore=all`. The only
3042         exception to that rule is that status and commit will show staged
3043         submodule changes. To
3044         also view the summary for ignored submodules you can either use
3045         the --ignore-submodules=dirty command-line option or the 'git
3046         submodule summary' command, which shows a similar output but does
3047         not honor these settings.
3049 stash.showPatch::
3050         If this is set to true, the `git stash show` command without an
3051         option will show the stash entry in patch form.  Defaults to false.
3052         See description of 'show' command in linkgit:git-stash[1].
3054 stash.showStat::
3055         If this is set to true, the `git stash show` command without an
3056         option will show diffstat of the stash entry.  Defaults to true.
3057         See description of 'show' command in linkgit:git-stash[1].
3059 submodule.<name>.url::
3060         The URL for a submodule. This variable is copied from the .gitmodules
3061         file to the git config via 'git submodule init'. The user can change
3062         the configured URL before obtaining the submodule via 'git submodule
3063         update'. If neither submodule.<name>.active or submodule.active are
3064         set, the presence of this variable is used as a fallback to indicate
3065         whether the submodule is of interest to git commands.
3066         See linkgit:git-submodule[1] and linkgit:gitmodules[5] for details.
3068 submodule.<name>.update::
3069         The default update procedure for a submodule. This variable
3070         is populated by `git submodule init` from the
3071         linkgit:gitmodules[5] file. See description of 'update'
3072         command in linkgit:git-submodule[1].
3074 submodule.<name>.branch::
3075         The remote branch name for a submodule, used by `git submodule
3076         update --remote`.  Set this option to override the value found in
3077         the `.gitmodules` file.  See linkgit:git-submodule[1] and
3078         linkgit:gitmodules[5] for details.
3080 submodule.<name>.fetchRecurseSubmodules::
3081         This option can be used to control recursive fetching of this
3082         submodule. It can be overridden by using the --[no-]recurse-submodules
3083         command-line option to "git fetch" and "git pull".
3084         This setting will override that from in the linkgit:gitmodules[5]
3085         file.
3087 submodule.<name>.ignore::
3088         Defines under what circumstances "git status" and the diff family show
3089         a submodule as modified. When set to "all", it will never be considered
3090         modified (but it will nonetheless show up in the output of status and
3091         commit when it has been staged), "dirty" will ignore all changes
3092         to the submodules work tree and
3093         takes only differences between the HEAD of the submodule and the commit
3094         recorded in the superproject into account. "untracked" will additionally
3095         let submodules with modified tracked files in their work tree show up.
3096         Using "none" (the default when this option is not set) also shows
3097         submodules that have untracked files in their work tree as changed.
3098         This setting overrides any setting made in .gitmodules for this submodule,
3099         both settings can be overridden on the command line by using the
3100         "--ignore-submodules" option. The 'git submodule' commands are not
3101         affected by this setting.
3103 submodule.<name>.active::
3104         Boolean value indicating if the submodule is of interest to git
3105         commands.  This config option takes precedence over the
3106         submodule.active config option.
3108 submodule.active::
3109         A repeated field which contains a pathspec used to match against a
3110         submodule's path to determine if the submodule is of interest to git
3111         commands.
3113 submodule.recurse::
3114         Specifies if commands recurse into submodules by default. This
3115         applies to all commands that have a `--recurse-submodules` option.
3116         Defaults to false.
3118 submodule.fetchJobs::
3119         Specifies how many submodules are fetched/cloned at the same time.
3120         A positive integer allows up to that number of submodules fetched
3121         in parallel. A value of 0 will give some reasonable default.
3122         If unset, it defaults to 1.
3124 submodule.alternateLocation::
3125         Specifies how the submodules obtain alternates when submodules are
3126         cloned. Possible values are `no`, `superproject`.
3127         By default `no` is assumed, which doesn't add references. When the
3128         value is set to `superproject` the submodule to be cloned computes
3129         its alternates location relative to the superprojects alternate.
3131 submodule.alternateErrorStrategy::
3132         Specifies how to treat errors with the alternates for a submodule
3133         as computed via `submodule.alternateLocation`. Possible values are
3134         `ignore`, `info`, `die`. Default is `die`.
3136 tag.forceSignAnnotated::
3137         A boolean to specify whether annotated tags created should be GPG signed.
3138         If `--annotate` is specified on the command line, it takes
3139         precedence over this option.
3141 tag.sort::
3142         This variable controls the sort ordering of tags when displayed by
3143         linkgit:git-tag[1]. Without the "--sort=<value>" option provided, the
3144         value of this variable will be used as the default.
3146 tar.umask::
3147         This variable can be used to restrict the permission bits of
3148         tar archive entries.  The default is 0002, which turns off the
3149         world write bit.  The special value "user" indicates that the
3150         archiving user's umask will be used instead.  See umask(2) and
3151         linkgit:git-archive[1].
3153 transfer.fsckObjects::
3154         When `fetch.fsckObjects` or `receive.fsckObjects` are
3155         not set, the value of this variable is used instead.
3156         Defaults to false.
3158 transfer.hideRefs::
3159         String(s) `receive-pack` and `upload-pack` use to decide which
3160         refs to omit from their initial advertisements.  Use more than
3161         one definition to specify multiple prefix strings. A ref that is
3162         under the hierarchies listed in the value of this variable is
3163         excluded, and is hidden when responding to `git push` or `git
3164         fetch`.  See `receive.hideRefs` and `uploadpack.hideRefs` for
3165         program-specific versions of this config.
3167 You may also include a `!` in front of the ref name to negate the entry,
3168 explicitly exposing it, even if an earlier entry marked it as hidden.
3169 If you have multiple hideRefs values, later entries override earlier ones
3170 (and entries in more-specific config files override less-specific ones).
3172 If a namespace is in use, the namespace prefix is stripped from each
3173 reference before it is matched against `transfer.hiderefs` patterns.
3174 For example, if `refs/heads/master` is specified in `transfer.hideRefs` and
3175 the current namespace is `foo`, then `refs/namespaces/foo/refs/heads/master`
3176 is omitted from the advertisements but `refs/heads/master` and
3177 `refs/namespaces/bar/refs/heads/master` are still advertised as so-called
3178 "have" lines. In order to match refs before stripping, add a `^` in front of
3179 the ref name. If you combine `!` and `^`, `!` must be specified first.
3181 Even if you hide refs, a client may still be able to steal the target
3182 objects via the techniques described in the "SECURITY" section of the
3183 linkgit:gitnamespaces[7] man page; it's best to keep private data in a
3184 separate repository.
3186 transfer.unpackLimit::
3187         When `fetch.unpackLimit` or `receive.unpackLimit` are
3188         not set, the value of this variable is used instead.
3189         The default value is 100.
3191 uploadarchive.allowUnreachable::
3192         If true, allow clients to use `git archive --remote` to request
3193         any tree, whether reachable from the ref tips or not. See the
3194         discussion in the "SECURITY" section of
3195         linkgit:git-upload-archive[1] for more details. Defaults to
3196         `false`.
3198 uploadpack.hideRefs::
3199         This variable is the same as `transfer.hideRefs`, but applies
3200         only to `upload-pack` (and so affects only fetches, not pushes).
3201         An attempt to fetch a hidden ref by `git fetch` will fail.  See
3202         also `uploadpack.allowTipSHA1InWant`.
3204 uploadpack.allowTipSHA1InWant::
3205         When `uploadpack.hideRefs` is in effect, allow `upload-pack`
3206         to accept a fetch request that asks for an object at the tip
3207         of a hidden ref (by default, such a request is rejected).
3208         See also `uploadpack.hideRefs`.  Even if this is false, a client
3209         may be able to steal objects via the techniques described in the
3210         "SECURITY" section of the linkgit:gitnamespaces[7] man page; it's
3211         best to keep private data in a separate repository.
3213 uploadpack.allowReachableSHA1InWant::
3214         Allow `upload-pack` to accept a fetch request that asks for an
3215         object that is reachable from any ref tip. However, note that
3216         calculating object reachability is computationally expensive.
3217         Defaults to `false`.  Even if this is false, a client may be able
3218         to steal objects via the techniques described in the "SECURITY"
3219         section of the linkgit:gitnamespaces[7] man page; it's best to
3220         keep private data in a separate repository.
3222 uploadpack.allowAnySHA1InWant::
3223         Allow `upload-pack` to accept a fetch request that asks for any
3224         object at all.
3225         Defaults to `false`.
3227 uploadpack.keepAlive::
3228         When `upload-pack` has started `pack-objects`, there may be a
3229         quiet period while `pack-objects` prepares the pack. Normally
3230         it would output progress information, but if `--quiet` was used
3231         for the fetch, `pack-objects` will output nothing at all until
3232         the pack data begins. Some clients and networks may consider
3233         the server to be hung and give up. Setting this option instructs
3234         `upload-pack` to send an empty keepalive packet every
3235         `uploadpack.keepAlive` seconds. Setting this option to 0
3236         disables keepalive packets entirely. The default is 5 seconds.
3238 uploadpack.packObjectsHook::
3239         If this option is set, when `upload-pack` would run
3240         `git pack-objects` to create a packfile for a client, it will
3241         run this shell command instead.  The `pack-objects` command and
3242         arguments it _would_ have run (including the `git pack-objects`
3243         at the beginning) are appended to the shell command. The stdin
3244         and stdout of the hook are treated as if `pack-objects` itself
3245         was run. I.e., `upload-pack` will feed input intended for
3246         `pack-objects` to the hook, and expects a completed packfile on
3247         stdout.
3249 Note that this configuration variable is ignored if it is seen in the
3250 repository-level config (this is a safety measure against fetching from
3251 untrusted repositories).
3253 url.<base>.insteadOf::
3254         Any URL that starts with this value will be rewritten to
3255         start, instead, with <base>. In cases where some site serves a
3256         large number of repositories, and serves them with multiple
3257         access methods, and some users need to use different access
3258         methods, this feature allows people to specify any of the
3259         equivalent URLs and have Git automatically rewrite the URL to
3260         the best alternative for the particular user, even for a
3261         never-before-seen repository on the site.  When more than one
3262         insteadOf strings match a given URL, the longest match is used.
3264 Note that any protocol restrictions will be applied to the rewritten
3265 URL. If the rewrite changes the URL to use a custom protocol or remote
3266 helper, you may need to adjust the `protocol.*.allow` config to permit
3267 the request.  In particular, protocols you expect to use for submodules
3268 must be set to `always` rather than the default of `user`. See the
3269 description of `protocol.allow` above.
3271 url.<base>.pushInsteadOf::
3272         Any URL that starts with this value will not be pushed to;
3273         instead, it will be rewritten to start with <base>, and the
3274         resulting URL will be pushed to. In cases where some site serves
3275         a large number of repositories, and serves them with multiple
3276         access methods, some of which do not allow push, this feature
3277         allows people to specify a pull-only URL and have Git
3278         automatically use an appropriate URL to push, even for a
3279         never-before-seen repository on the site.  When more than one
3280         pushInsteadOf strings match a given URL, the longest match is
3281         used.  If a remote has an explicit pushurl, Git will ignore this
3282         setting for that remote.
3284 user.email::
3285         Your email address to be recorded in any newly created commits.
3286         Can be overridden by the `GIT_AUTHOR_EMAIL`, `GIT_COMMITTER_EMAIL`, and
3287         `EMAIL` environment variables.  See linkgit:git-commit-tree[1].
3289 user.name::
3290         Your full name to be recorded in any newly created commits.
3291         Can be overridden by the `GIT_AUTHOR_NAME` and `GIT_COMMITTER_NAME`
3292         environment variables.  See linkgit:git-commit-tree[1].
3294 user.useConfigOnly::
3295         Instruct Git to avoid trying to guess defaults for `user.email`
3296         and `user.name`, and instead retrieve the values only from the
3297         configuration. For example, if you have multiple email addresses
3298         and would like to use a different one for each repository, then
3299         with this configuration option set to `true` in the global config
3300         along with a name, Git will prompt you to set up an email before
3301         making new commits in a newly cloned repository.
3302         Defaults to `false`.
3304 user.signingKey::
3305         If linkgit:git-tag[1] or linkgit:git-commit[1] is not selecting the
3306         key you want it to automatically when creating a signed tag or
3307         commit, you can override the default selection with this variable.
3308         This option is passed unchanged to gpg's --local-user parameter,
3309         so you may specify a key using any method that gpg supports.
3311 versionsort.prereleaseSuffix (deprecated)::
3312         Deprecated alias for `versionsort.suffix`.  Ignored if
3313         `versionsort.suffix` is set.
3315 versionsort.suffix::
3316         Even when version sort is used in linkgit:git-tag[1], tagnames
3317         with the same base version but different suffixes are still sorted
3318         lexicographically, resulting e.g. in prerelease tags appearing
3319         after the main release (e.g. "1.0-rc1" after "1.0").  This
3320         variable can be specified to determine the sorting order of tags
3321         with different suffixes.
3323 By specifying a single suffix in this variable, any tagname containing
3324 that suffix will appear before the corresponding main release.  E.g. if
3325 the variable is set to "-rc", then all "1.0-rcX" tags will appear before
3326 "1.0".  If specified multiple times, once per suffix, then the order of
3327 suffixes in the configuration will determine the sorting order of tagnames
3328 with those suffixes.  E.g. if "-pre" appears before "-rc" in the
3329 configuration, then all "1.0-preX" tags will be listed before any
3330 "1.0-rcX" tags.  The placement of the main release tag relative to tags
3331 with various suffixes can be determined by specifying the empty suffix
3332 among those other suffixes.  E.g. if the suffixes "-rc", "", "-ck" and
3333 "-bfs" appear in the configuration in this order, then all "v4.8-rcX" tags
3334 are listed first, followed by "v4.8", then "v4.8-ckX" and finally
3335 "v4.8-bfsX".
3337 If more than one suffixes match the same tagname, then that tagname will
3338 be sorted according to the suffix which starts at the earliest position in
3339 the tagname.  If more than one different matching suffixes start at
3340 that earliest position, then that tagname will be sorted according to the
3341 longest of those suffixes.
3342 The sorting order between different suffixes is undefined if they are
3343 in multiple config files.
3345 web.browser::
3346         Specify a web browser that may be used by some commands.
3347         Currently only linkgit:git-instaweb[1] and linkgit:git-help[1]
3348         may use it.