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