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