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