Protected configuration refers to thesystem,global, andcommand scopes.For security reasons, certain options are only respected when they arespecified in protected configuration, and ignored otherwise.

Git treats these scopes as if they are controlled by the user or a trustedadministrator. This is because an attacker who controls these scopes can dosubstantial harm without using Git, so it is assumed that the user’s environmentprotects these scopes against attackers.

## This is the config file, and# a '#' or ';' character indicates# a comment#; core variables[core]        ; Don't trust file modes        filemode = false; Our diff algorithm[diff]        external = /usr/local/bin/diff-wrapper        renames = true; Proxy settings[core]        gitproxy=proxy-command for kernel.org        gitproxy=default-proxy ; for all the rest; HTTP[http]        sslVerify[http "https://weak.example.com"]        sslVerify = false        cookieFile = /tmp/cookie.txt

% git config set core.filemode true

% git config set --value='for kernel.org$' core.gitproxy '"ssh" for kernel.org'

% git config unset diff.renames

% git config get core.filemode

% git config get --value="for kernel.org$" core.gitproxy

% git config get --all --show-names core.gitproxy

% git config set --all core.gitproxy ssh

% git config set --value='! for ' core.gitproxy ssh

% git config set --value='[!]' section.key value

% git config set --append core.gitproxy '"proxy-command" for example.com'

#!/bin/shWS=$(git config get --type=color --default="blue reverse" color.diff.whitespace)RESET=$(git config get --type=color --default="reset" "")echo "${WS}your whitespace color or blue reverse${RESET}"

% git config get --type=bool --url=https://good.example.com http.sslverifytrue% git config get --type=bool --url=https://weak.example.com http.sslverifyfalse% git config get --url=https://weak.example.com httphttp.cookieFile /tmp/cookie.txthttp.sslverify false

The syntax is fairly flexible and permissive. Whitespace characters,which in this context are the space character (SP) and the horizontaltabulation (HT), are mostly ignored. The# and; characters begincomments to the end of line. Blank lines are ignored.

The file consists of sections and variables. A section begins withthe name of the section in square brackets and continues until the nextsection begins. Section names are case-insensitive. Only alphanumericcharacters,- and . are allowed in section names. Each variablemust belong to some section, which means that there must be a sectionheader before the first setting of a variable.

Sections can be further divided into subsections. To begin a subsectionput its name in double quotes, separated by space from the section name,in the section header, like in the example below:

Subsection names are case sensitive and can contain any characters exceptnewline and the null byte. Doublequote " and backslash can be includedby escaping them as\" and\\, respectively. Backslashes precedingother characters are dropped when reading; for example,\t is read ast and\0 is read as0. Section headers cannot span multiple lines.Variables may belong directly to a section or to a given subsection. Youcan have [section] if you have [section "subsection"], but you don’tneed to.

There is also a deprecated [section.subsection] syntax. With thissyntax, the subsection name is converted to lower-case and is alsocompared case sensitively. These subsection names follow the samerestrictions as section names.

All the other lines (and the remainder of the line after the sectionheader) are recognized as setting variables, in the formname = value (or justname, which is a short-hand to say thatthe variable is the boolean "true").The variable names are case-insensitive, allow only alphanumeric charactersand-, and must start with an alphabetic character.

Whitespace characters surroundingname,= andvalue are discarded.Internal whitespace characters withinvalue are retained verbatim.Comments starting with either # or ; and extending to the end of lineare discarded. A line that defines a value can be continued to the nextline by ending it with a backslash (\); the backslash and the end-of-linecharacters are discarded.

Ifvalue needs to contain leading or trailing whitespace characters,it must be enclosed in double quotation marks ("). Inside double quotationmarks, double quote (") and backslash (\) characters must be escaped:use\" for " and\\ for\.

The following escape sequences (beside\" and\\) are recognized:\n for newline character (NL),\t for horizontal tabulation (HT, TAB)and\b for backspace (BS). Other char escape sequences (including octalescape sequences) are invalid.

Theinclude andincludeIf sections allow you to include configdirectives from another source. These sections behave identically toeach other with the exception thatincludeIf sections may be ignoredif their condition does not evaluate to true; see "Conditional includes"below.

You can include a config file from another by setting the specialinclude.path (orincludeIf.*.path) variable to the name of the fileto be included. The variable takes a pathname as its value, and issubject to tilde expansion. These variables can be given multiple times.

The contents of the included file are inserted immediately, as if theyhad been found at the location of the include directive. If the value of thevariable is a relative path, the path is considered tobe relative to the configuration file in which the include directivewas found. See below for examples.

You can conditionally include a config file from another by setting anincludeIf.<condition>.path variable to the name of the file to beincluded.

The condition starts with a keyword followed by a colon and some datawhose format and meaning depends on the keyword. Supported keywordsare:

gitdir

The data that follows the keywordgitdir and a colon is used as a globpattern. If the location of the .git directory matches thepattern, the include condition is met.

The .git location may be auto-discovered, or come from$GIT_DIRenvironment variable. If the repository is auto-discovered via a .gitfile (e.g. from submodules, or a linked worktree), the .git locationwould be the final location where the .git directory is, not where the.git file is.

The pattern can contain standard globbing wildcards and two additionalones,**/ and/**, that can match multiple path components. Pleaserefer togitignore(5) for details. For convenience:

• If the pattern starts with~/,~ will be substituted with thecontent of the environment variableHOME.

• If the pattern starts with ./, it is replaced with the directorycontaining the current config file.

• If the pattern does not start with either~/, ./ or/,**/will be automatically prepended. For example, the patternfoo/barbecomes**/foo/bar and would match/any/path/to/foo/bar.

• If the pattern ends with/,** will be automatically added. Forexample, the patternfoo/ becomesfoo/**. In other words, itmatches "foo" and everything inside, recursively.

gitdir/i

This is the same asgitdir except that matching is donecase-insensitively (e.g. on case-insensitive file systems)

onbranch

The data that follows the keywordonbranch and a colon is taken to be apattern with standard globbing wildcards and two additionalones,**/ and/**, that can match multiple path components.If we are in a worktree where the name of the branch that iscurrently checked out matches the pattern, the include conditionis met.

If the pattern ends with/,** will be automatically added. Forexample, the patternfoo/ becomesfoo/**. In other words, it matchesall branches that begin withfoo/. This is useful if your branches areorganized hierarchically and you would like to apply a configuration toall the branches in that hierarchy.

hasconfig:remote.*.url

The data that follows this keyword and a colon is taken tobe a pattern with standard globbing wildcards and twoadditional ones,**/ and/**, that can match multiplecomponents. The first time this keyword is seen, the rest ofthe config files will be scanned for remote URLs (withoutapplying any values). If there exists at least one remote URLthat matches this pattern, the include condition is met.

Files included by this option (directly or indirectly) are not allowedto contain remote URLs.

Note that unlike other includeIf conditions, resolving this conditionrelies on information that is not yet known at the point of reading thecondition. A typical use case is this option being present as asystem-level or global-level config, and the remote URL being in alocal-level config; hence the need to scan ahead when resolving thiscondition. In order to avoid the chicken-and-egg problem in whichpotentially-included files can affect whether such files are potentiallyincluded, Git breaks the cycle by prohibiting these files from affectingthe resolution of these conditions (thus, prohibiting them fromdeclaring remote URLs).

As for the naming of this keyword, it is for forwards compatibility witha naming scheme that supports more variable-based include conditions,but currently Git only supports the exact keyword described above.

A few more notes on matching viagitdir andgitdir/i:

• Symlinks in$GIT_DIR are not resolved before matching.

• Both the symlink & realpath versions of paths will be matchedoutside of$GIT_DIR. E.g. if ~/git is a symlink to/mnt/storage/git, bothgitdir:~/git andgitdir:/mnt/storage/gitwill match.

  This was not the case in the initial release of this feature inv2.13.0, which only matched the realpath version. Configuration thatwants to be compatible with the initial release of this feature needsto either specify only the realpath version, or both versions.

• Note that "../" is not special and will match literally, which isunlikely what you want.

Values of many variables are treated as a simple string, but thereare variables that take values of specific types and there are rulesas to how to spell them.

boolean

When a variable is said to take a boolean value, manysynonyms are accepted fortrue andfalse; these are allcase-insensitive.

true

Boolean true literals areyes,on,true,and1. Also, a variable defined without=<value>is taken as true.

false

Boolean false literals areno,off,false,0 and the empty string.

When converting a value to its canonical form using the--type=bool typespecifier,git config will ensure that the output is "true" or"false" (spelled in lowercase).

integer

The value for many variables that specify various sizes canbe suffixed withk,M,…​ to mean "scale the number by1024", "by 1024x1024", etc.

color

The value for a variable that takes a color is a list ofcolors (at most two, one for foreground and one for background)and attributes (as many as you want), separated by spaces.

The basic colors accepted arenormal,black,red,green,yellow,blue,magenta,cyan,white anddefault. The firstcolor given is the foreground; the second is the background. All thebasic colors exceptnormal anddefault have a bright variant that canbe specified by prefixing the color withbright, likebrightred.

The colornormal makes no change to the color. It is the same as anempty string, but can be used as the foreground color when specifying abackground color alone (for example, "normal red").

The colordefault explicitly resets the color to the terminal default,for example to specify a cleared background. Although it varies betweenterminals, this is usually not the same as setting to "white black".

Colors may also be given as numbers between 0 and 255; these use ANSI256-color mode (but note that not all terminals may support this). Ifyour terminal supports it, you may also specify 24-bit RGB values ashex, like #ff0ab3, or 12-bit RGB values like #f1b, which isequivalent to the 24-bit color #ff11bb.

The accepted attributes arebold,dim,ul,blink,reverse,italic, andstrike (for crossed-out or "strikethrough" letters).The position of any attributes with respect to the colors(before, after, or in between), doesn’t matter. Specific attributes maybe turned off by prefixing them withno orno- (e.g.,noreverse,no-ul, etc).

The pseudo-attributereset resets all colors and attributes beforeapplying the specified coloring. For example,resetgreen will resultin a green foreground and default background without any activeattributes.

An empty color string produces no color effect at all. This can be usedto avoid coloring specific elements without disabling color entirely.

For git’s pre-defined color slots, the attributes are meant to be resetat the beginning of each item in the colored output. So settingcolor.decorate.branch toblack will paint that branch name in aplainblack, even if the previous thing on the same output line (e.g.opening parenthesis before the list of branch names inlog--decorateoutput) is set to be painted withbold or some other attribute.However, custom log formats may do more complicated and layeredcoloring, and the negated forms may be useful there.

pathname

A variable that takes a pathname value can be given astring that begins with "~/" or "~user/", and the usualtilde expansion happens to such a string:~/is expanded to the value of$HOME, and~user/ to thespecified user’s home directory.

If a path starts with%(prefix)/, the remainder is interpreted as apath relative to Git’s "runtime prefix", i.e. relative to the locationwhere Git itself was installed. For example,%(prefix)/bin/ refers tothe directory in which the Git executable itself lives. If Git wascompiled without runtime prefix support, the compiled-in prefix will besubstituted instead. In the unlikely event that a literal path needs tobe specified that shouldnot be expanded, it needs to be prefixed by./, like so: ./%(prefix)/bin.

If prefixed with:(optional), the configuration variable is treatedas if it does not exist, if the named path does not exist.

Note that this list is non-comprehensive and not necessarily complete.For command-specific variables, you will find a more detailed descriptionin the appropriate manual page.

Other git-related tools may and do use their own variables. Wheninventing new variables for use in your own tool, make sure theirnames do not conflict with those that are used by Git itself andother popular tools, and describe them in your documentation.

add.ignoreErrors

add.ignore-errors (deprecated)

Tellsgitadd to continue adding files when some files cannot beadded due to indexing errors.Equivalent to the--ignore-errors option ofgit-add(1).add.ignore-errors is deprecated, as it does not follow the usualnaming convention for configuration variables.

advice.*

These variables control various optional help messages designed toaid new users. When left unconfigured, Git will give the messagealongside instructions on how to squelch it. You can tell Gitthat you have understood the issue and no longer need a specifichelp message by setting the corresponding variable tofalse.

As they are intended to help human users, these messages are output tothe standard error. When tools that run Git as a subprocess find themdisruptive, they can setGIT_ADVICE=0 in the environment to squelchall advice messages.

addEmbeddedRepo

Shown when the user accidentally adds onegit repo inside of another.

addEmptyPathspec

Shown when the user runsgitadd without providingthe pathspec parameter.

addIgnoredFile

Shown when the user attempts to add an ignored file tothe index.

amWorkDir

Shown whengit-am(1) fails to apply a patchfile, to tell the user the location of the file.

ambiguousFetchRefspec

Shown when a fetch refspec for multiple remotes maps tothe same remote-tracking branch namespace and causes branchtracking set-up to fail.

checkoutAmbiguousRemoteBranchName

Shown when the argument togit-checkout(1) andgit-switch(1)ambiguously resolves to aremote tracking branch on more than one remote insituations where an unambiguous argument would haveotherwise caused a remote-tracking branch to bechecked out. See thecheckout.defaultRemoteconfiguration variable for how to set a given remoteto be used by default in some situations where thisadvice would be printed.

commitBeforeMerge

Shown whengit-merge(1) refuses tomerge to avoid overwriting local changes.

detachedHead

Shown when the user usesgit-switch(1) orgit-checkout(1)to move to the detached HEAD state, to tell the user howto create a local branch after the fact.

diverging

Shown when a fast-forward is not possible.

fetchShowForcedUpdates

Shown whengit-fetch(1) takes a long timeto calculate forced updates after ref updates, or to warnthat the check is disabled.

forceDeleteBranch

Shown when the user tries to delete a not fully mergedbranch without the force option set.

ignoredHook

Shown when a hook is ignored because the hook is notset as executable.

implicitIdentity

Shown when the user’s information is guessed from thesystem username and domain name, to tell the user how toset their identity configuration.

mergeConflict

Shown when various commands stop because of conflicts.

nestedTag

Shown when a user attempts to recursively tag a tag object.

pushAlreadyExists

Shown whengit-push(1) rejects an update thatdoes not qualify for fast-forwarding (e.g., a tag.)

pushFetchFirst

Shown whengit-push(1) rejects an update thattries to overwrite a remote ref that points at anobject we do not have.

pushNeedsForce

Shown whengit-push(1) rejects an update thattries to overwrite a remote ref that points at anobject that is not a commit-ish, or make the remoteref point at an object that is not a commit-ish.

pushNonFFCurrent

Shown whengit-push(1) fails due to anon-fast-forward update to the current branch.

pushNonFFMatching

Shown when the user rangit-push(1) and pushed"matching refs" explicitly (i.e. used:, orspecified a refspec that isn’t the current branch) andit resulted in a non-fast-forward error.

pushRefNeedsUpdate

Shown whengit-push(1) rejects a forced update ofa branch when its remote-tracking ref has updates that wedo not have locally.

pushUnqualifiedRefname

Shown whengit-push(1) gives up trying toguess based on the source and destination refs whatremote ref namespace the source belongs in, but wherewe can still suggest that the user push to eitherrefs/heads/* orrefs/tags/* based on the type of thesource object.

pushUpdateRejected

Set this variable tofalse if you want to disablepushNonFFCurrent,pushNonFFMatching,pushAlreadyExists,pushFetchFirst,pushNeedsForce, andpushRefNeedsUpdatesimultaneously.

rebaseTodoError

Shown when there is an error after editing the rebase todo list.

refSyntax

Shown when the user provides an illegal ref name, totell the user about the ref syntax documentation.

resetNoRefresh

Shown whengit-reset(1) takes more than 2seconds to refresh the index after reset, to tell the userthat they can use the--no-refresh option.

resolveConflict

Shown by various commands when conflictsprevent the operation from being performed.

rmHints

Shown on failure in the output ofgit-rm(1), togive directions on how to proceed from the current state.

sequencerInUse

Shown when a sequencer command is already in progress.

skippedCherryPicks

Shown whengit-rebase(1) skips a commit that has alreadybeen cherry-picked onto the upstream branch.

sparseIndexExpanded

Shown when a sparse index is expanded to a full index, which is likelydue to an unexpected set of files existing outside of thesparse-checkout.

statusAheadBehind

Shown whengit-status(1) computes the ahead/behindcounts for a local ref compared to its remote tracking ref,and that calculation takes longer than expected. Will notappear ifstatus.aheadBehind is false or the option--no-ahead-behind is given.

statusHints

Show directions on how to proceed from the currentstate in the output ofgit-status(1), inthe template shown when writing commit messages ingit-commit(1), and in the help message shownbygit-switch(1) orgit-checkout(1) when switching branches.

statusUoption

Shown whengit-status(1) takes more than 2seconds to enumerate untracked files, to tell the user thatthey can use the-u option.

submoduleAlternateErrorStrategyDie

Shown when a submodule.alternateErrorStrategy optionconfigured to "die" causes a fatal error.

submoduleMergeConflict

Advice shown when a non-trivial submodule merge conflict isencountered.

submodulesNotUpdated

Shown when a user runs a submodule command that failsbecausegitsubmoduleupdate--init was not run.

suggestDetachingHead

Shown whengit-switch(1) refuses to detach HEADwithout the explicit--detach option.

updateSparsePath

Shown when eithergit-add(1) orgit-rm(1)is asked to update index entries outside the current sparsecheckout.

waitingForEditor

Shown when Git is waiting for editor input. Relevantwhen e.g. the editor is not launched inside the terminal.

worktreeAddOrphan

Shown when the user tries to create a worktree from aninvalid reference, to tell the user how to create a new unbornbranch instead.

alias.*

Command aliases for thegit(1) command wrapper - e.g.after definingalias.last=cat-filecommitHEAD, the invocationgitlast is equivalent togitcat-filecommitHEAD. To avoidconfusion and troubles with script usage, aliases thathide existing Git commands are ignored except for deprecatedcommands. Arguments are split byspaces, the usual shell quoting and escaping are supported.A quote pair or a backslash can be used to quote them.

Note that the first word of an alias does not necessarily have to be acommand. It can be a command-line option that will be passed into theinvocation ofgit. In particular, this is useful when used with-cto pass in one-time configurations or-p to force pagination. For example,loud-rebase=-ccommit.verbose=truerebase can be defined such thatrunninggitloud-rebase would be equivalent togit-ccommit.verbose=truerebase. Also,ps=-pstatus would be ahelpful alias sincegitps would paginate the output ofgitstatuswhere the original command does not.

If the alias expansion is prefixed with an exclamation point,it will be treated as a shell command. For example, definingalias.new= !gitk--all--notORIG_HEAD, the invocationgitnew is equivalent to running the shell commandgitk--all--notORIG_HEAD. Note:

• Shell commands will be executed from the top-level directory of arepository, which may not necessarily be the current directory.

• GIT_PREFIX is set as returned by runninggitrev-parse--show-prefixfrom the original current directory. Seegit-rev-parse(1).

• Shell command aliases always receive any extra arguments provided tothe Git command-line as positional arguments.

  • Care should be taken if your shell alias is a "one-liner" scriptwith multiple commands (e.g. in a pipeline), references multiplearguments, or is otherwise not able to handle positional argumentsadded at the end. For example:alias.cmd= "!echo$1 |grep$2"called asgitcmd12 will be executed asecho $1 | grep $21 2, which is not what you want.

  • A convenient way to deal with this is to write your scriptoperations in an inline function that is then called with anyarguments from the command-line. For examplealias.cmd= "!c() {echo$1 |grep$2 ; };c" will correctly execute the prior example.

  • SettingGIT_TRACE=1 can help you debug the command being run foryour alias.

am.keepcr

If true, git-am will call git-mailsplit for patches in mbox formatwith parameter--keep-cr. In this case git-mailsplit willnot remove\r from lines ending with\r\n. Can be overriddenby giving--no-keep-cr from the command line.Seegit-am(1),git-mailsplit(1).

am.threeWay

By default,gitam will fail if the patch does not apply cleanly. Whenset to true, this setting tellsgitam to fall back on 3-way merge ifthe patch records the identity of blobs it is supposed to apply to andwe have those blobs available locally (equivalent to giving the--3wayoption from the command line). Defaults tofalse.Seegit-am(1).

apply.ignoreWhitespace

When set tochange, tellsgit apply to ignore changes inwhitespace, in the same way as the--ignore-space-changeoption.When set to one of: no, none, never, false, it tellsgit apply torespect all whitespace differences.Seegit-apply(1).

apply.whitespace

Tellsgit apply how to handle whitespace, in the same wayas the--whitespace option. Seegit-apply(1).

attr.tree

A reference to a tree in the repository from which to read attributes,instead of the .gitattributes file in the working tree. If the valuedoes not resolve to a valid tree object, an empty tree is used instead.When theGIT_ATTR_SOURCE environment variable or--attr-sourcecommand line option are used, this configuration variable has no effect.

bitmapPseudoMerge.<name>.pattern

Regular expression used to match reference names. Commitspointed to by references matching this pattern (and meetingthe below criteria, likebitmapPseudoMerge.<name>.sampleRateandbitmapPseudoMerge.<name>.threshold) will be consideredfor inclusion in a pseudo-merge bitmap.

Commits are grouped into pseudo-merge groups based on whether or notany reference(s) that point at a given commit match the pattern, whichis an extended regular expression.

Within a pseudo-merge group, commits may be further grouped intosub-groups based on the capture groups in the pattern. Thesesub-groupings are formed from the regular expressions by concatenatingany capture groups from the regular expression, with a- dash inbetween.

For example, if the pattern isrefs/tags/, then all tags (providedthey meet the below criteria) will be considered candidates for thesame pseudo-merge group. However, if the pattern is insteadrefs/remotes/([0-9])+/tags/, then tags from different remotes willbe grouped into separate pseudo-merge groups, based on the remotenumber.

bitmapPseudoMerge.<name>.decay

Determines the rate at which consecutive pseudo-merge bitmapgroups decrease in size. Must be non-negative. This parametercan be thought of ask in the functionf(n)=C*n^-k,wheref(n) is the size of the `n`th group.

Setting the decay rate equal to0 will cause all groups to be thesame size. Setting the decay rate equal to1 will cause then`thgrouptobe `1/n the size of the initial group. Higher values of thedecay rate cause consecutive groups to shrink at an increasing rate.The default is1.

If all groups are the same size, it is possible that groups containingnewer commits will be able to be used less often than earlier groups,since it is more likely that the references pointing at newer commitswill be updated more often than a reference pointing at an old commit.

bitmapPseudoMerge.<name>.sampleRate

Determines the proportion of non-bitmapped commits (amongreference tips) which are selected for inclusion in anunstable pseudo-merge bitmap. Must be between0 and1(inclusive). The default is1.

bitmapPseudoMerge.<name>.threshold

Determines the minimum age of non-bitmapped commits (amongreference tips, as above) which are candidates for inclusionin an unstable pseudo-merge bitmap. The default is1.week.ago.

bitmapPseudoMerge.<name>.maxMerges

Determines the maximum number of pseudo-merge commits amongwhich commits may be distributed.

For pseudo-merge groups whose pattern does not contain any capturegroups, this setting is applied for all commits matching the regularexpression. For patterns that have one or more capture groups, thissetting is applied for each distinct capture group.

For example, if your capture group isrefs/tags/, then this settingwill distribute all tags into a maximum ofmaxMerges pseudo-mergecommits. However, if your capture group is, say,refs/remotes/([0-9]+)/tags/, then this setting will be applied toeach remote’s set of tags individually.

Must be non-negative. The default value is 64.

bitmapPseudoMerge.<name>.stableThreshold

Determines the minimum age of commits (among reference tips,as above, however stable commits are still consideredcandidates even when they have been covered by a bitmap) whichare candidates for a stable a pseudo-merge bitmap. The defaultis1.month.ago.

Setting this threshold to a smaller value (e.g., 1.week.ago) will causemore stable groups to be generated (which impose a one-time generationcost) but those groups will likely become stale over time. Using alarger value incurs the opposite penalty (fewer stable groups which aremore useful).

bitmapPseudoMerge.<name>.stableSize

Determines the size (in number of commits) of a stablepsuedo-merge bitmap. The default is512.

blame.blankBoundary

Show blank commit object name for boundary commits ingit-blame(1). This option defaults to false.

blame.coloring

This determines the coloring scheme to be applied to blameoutput. It can berepeatedLines,highlightRecent,ornone which is the default.

blame.date

Specifies the format used to output dates ingit-blame(1).If unset the iso format is used. For supported values,see the discussion of the--date option atgit-log(1).

blame.showEmail

Show the author email instead of author name ingit-blame(1).This option defaults to false.

blame.showRoot

Do not treat root commits as boundaries ingit-blame(1).This option defaults to false.

blame.ignoreRevsFile

Ignore revisions listed in the file, one unabbreviated object name perline, ingit-blame(1). Whitespace and comments beginning with# are ignored. This option may be repeated multiple times. Emptyfile names will reset the list of ignored revisions. This option willbe handled before the command line option--ignore-revs-file.

blame.markUnblamableLines

Mark lines that were changed by an ignored revision that we could notattribute to another commit with a* in the output ofgit-blame(1).

blame.markIgnoredLines

Mark lines that were changed by an ignored revision that we attributed toanother commit with a? in the output ofgit-blame(1).

branch.autoSetupMerge

Tellsgitbranch,gitswitch andgitcheckout to set up new branchesso thatgit-pull(1) will appropriately merge from thestarting point branch. Note that even if this option is not set,this behavior can be chosen per-branch using the--trackand--no-track options. This option defaults totrue. The valid settingsare:

false

no automatic setup is done

true

automatic setup is done when the starting point is a remote-tracking branch

always

automatic setup is done when the starting point is either alocal branch or remote-tracking branch

inherit

if the starting point has a tracking configuration, it is copied to the newbranch

simple

automatic setup is done only when the starting pointis a remote-tracking branch and the new branch has the same name as theremote branch.

branch.autoSetupRebase

When a new branch is created withgitbranch,gitswitch orgitcheckoutthat tracks another branch, this variable tells Git to setup pull to rebase instead of merge (seebranch.<name>.rebase).The valid settings are:

never

rebase is never automatically set to true.

local

rebase is set to true for tracked branches of other local branches.

remote

rebase is set to true for tracked branches of remote-tracking branches.

always

rebase will be set to true for all tracking branches.

Seebranch.autoSetupMerge for details on how to set up a branch to track another branch.This option defaults tonever.

branch.sort

This variable controls the sort ordering of branches when displayed bygit-branch(1). Without the--sort=<value> option provided, thevalue of this variable will be used as the default.Seegit-for-each-ref(1) field names for valid values.

branch.<name>.remote

When on branch<name>, it tellsgitfetch andgitpushwhich remote to fetch from or push to. The remote to push tomay be overridden withremote.pushDefault (for all branches).The remote to push to, for the current branch, may be furtheroverridden bybranch.<name>.pushRemote. If no remote isconfigured, or if you are not on any branch and there is more thanone remote defined in the repository, it defaults toorigin forfetching andremote.pushDefault for pushing.Additionally, . (a period) is the current local repository(a dot-repository), seebranch.<name>.merge's final note below.

branch.<name>.pushRemote

When on branch<name>, it overridesbranch.<name>.remote forpushing. It also overridesremote.pushDefault for pushingfrom branch<name>. When you pull from one place (e.g. yourupstream) and push to another place (e.g. your own publishingrepository), you would want to setremote.pushDefault tospecify the remote to push to for all branches, and use thisoption to override it for a specific branch.

branch.<name>.merge

Defines, together withbranch.<name>.remote, the upstream branchfor the given branch. It tellsgitfetch/gitpull/gitrebase whichbranch to merge and can also affectgitpush (seepush.default).When in branch<name>, it tellsgitfetch the defaultrefspec to be marked for merging inFETCH_HEAD. The value ishandled like the remote part of a refspec, and must match aref which is fetched from the remote given bybranch.<name>.remote.The merge information is used bygitpull (which first callsgitfetch) to lookup the default branch for merging. Withoutthis option,gitpull defaults to merge the first refspec fetched.Specify multiple values to get an octopus merge.If you wish to setupgitpull so that it merges into<name> fromanother branch in the local repository, you can pointbranch.<name>.merge to the desired branch, and use the relative pathsetting . (a period) forbranch.<name>.remote.

branch.<name>.mergeOptions

Sets default options for merging into branch<name>. The syntax andsupported options are the same as those ofgit-merge(1), butoption values containing whitespace characters are currently notsupported.

branch.<name>.rebase

When true, rebase the branch<name> on top of the fetched branch,instead of merging the default branch from the default remote whengitpull is run. Seepull.rebase for doing this in a nonbranch-specific manner.

Whenmerges (or justm), pass the--rebase-merges option togitrebaseso that the local merge commits are included in the rebase (seegit-rebase(1) for details).

When the value isinteractive (or justi), the rebase is run in interactivemode.

NOTE: this is a possibly dangerous operation; donot useit unless you understand the implications (seegit-rebase(1)for details).

branch.<name>.description

Branch description, can be edited withgitbranch--edit-description. Branch description isautomatically added to theformat-patch cover letter orrequest-pull summary.

browser.<tool>.cmd

Specify the command to invoke the specified browser. Thespecified command is evaluated in shell with the URLs passedas arguments. (Seegit-web--browse(1).)

browser.<tool>.path

Override the path for the given tool that may be used tobrowse HTML help (see-w option ingit-help(1)) or aworking repository in gitweb (seegit-instaweb(1)).

bundle.*

Thebundle.* keys may appear in a bundle list file found via thegitclone--bundle-uri option. These keys currently have no effectif placed in a repository config file, though this will change in thefuture. Seethe bundle URI designdocument for more details.

bundle.version

This integer value advertises the version of the bundle list formatused by the bundle list. Currently, the only accepted value is1.

bundle.mode

This string value should be eitherall orany. This value describeswhether all of the advertised bundles are required to unbundle acomplete understanding of the bundled information (all) or if any oneof the listed bundle URIs is sufficient (any).

bundle.heuristic

If this string-valued key exists, then the bundle list is designed towork well with incrementalgitfetch commands. The heuristic signalsthat there are additional keys available for each bundle that helpdetermine which subset of bundles the client should download. Theonly value currently understood iscreationToken.

bundle.<id>.*

Thebundle.<id>.* keys are used to describe a single item in thebundle list, grouped under<id> for identification purposes.

bundle.<id>.uri

This string value defines the URI by which Git can reach the contentsof this<id>. This URI may be a bundle file or another bundle list.

checkout.defaultRemote

When you rungitcheckout<something>orgitswitch<something> and only have oneremote, it may implicitly fall back on checking out andtracking e.g.origin/<something>. This stops working as soonas you have more than one remote with a<something>reference. This setting allows for setting the name of apreferred remote that should always win when it comes todisambiguation. The typical use-case is to set this toorigin.

Currently this is used bygit-switch(1) andgit-checkout(1) whengitcheckout<something>orgitswitch<something>will checkout the<something> branch on another remote,and bygit-worktree(1) whengitworktreeadd refers to aremote branch. This setting might be used for other checkout-likecommands or functionality in the future.

checkout.guess

Provides the default value for the--guess or--no-guessoption ingitcheckout andgitswitch. Seegit-switch(1) andgit-checkout(1).

checkout.workers

The number of parallel workers to use when updating the working tree.The default is one, i.e. sequential execution. If set to a value lessthan one, Git will use as many workers as the number of logical coresavailable. This setting andcheckout.thresholdForParallelism affectall commands that perform checkout. E.g. checkout, clone, reset,sparse-checkout, etc.

Note

Parallel checkout usually delivers better performance for repositorieslocated on SSDs or over NFS. For repositories on spinning disks and/or machineswith a small number of cores, the default sequential checkout often performsbetter. The size and compression level of a repository might also influence howwell the parallel version performs.

checkout.thresholdForParallelism

When running parallel checkout with a small number of files, the costof subprocess spawning and inter-process communication might outweighthe parallelization gains. This setting allows you to define the minimumnumber of files for which parallel checkout should be attempted. Thedefault is 100.

clean.requireForce

A boolean to make git-clean refuse to delete files unless -fis given. Defaults to true.

clone.defaultRemoteName

The name of the remote to create when cloning a repository. Defaults toorigin.It can be overridden by passing the--origin command-lineoption togit-clone(1).

clone.rejectShallow

Reject cloning a repository if it is a shallow one; this can be overridden bypassing the--reject-shallow option on the command line.Seegit-clone(1).

clone.filterSubmodules

If a partial clone filter is provided (see--filter ingit-rev-list(1)) and--recurse-submodules is used, also applythe filter to submodules.

color.advice

A boolean to enable/disable color in hints (e.g. when a pushfailed, seeadvice.* for a list). May be set toalways,false (ornever) orauto (ortrue), in which case colorsare used only when the error output goes to a terminal. Ifunset, then the value ofcolor.ui is used (auto by default).

color.advice.hint

Use customized color for hints.

color.blame.highlightRecent

Specify the line annotation color forgitblame--color-by-agedepending upon the age of the line.

This setting should be set to a comma-separated list of color anddate settings, starting and ending with a color, the dates should beset from oldest to newest. The metadata will be colored with thespecified colors if the line was introduced before the giventimestamp, overwriting older timestamped colors.

Instead of an absolute timestamp relative timestamps work as well,e.g.2.weeks.ago is valid to address anything older than 2 weeks.

It defaults toblue,12monthago,white,1monthago,red, whichcolors everything older than one year blue, recent changes betweenone month and one year old are kept white, and lines introducedwithin the last month are colored red.

color.blame.repeatedLines

Use the specified color to colorize line annotations forgitblame--color-lines, if they come from the same commit as thepreceding line. Defaults to cyan.

color.branch

A boolean to enable/disable color in the output ofgit-branch(1). May be set toalways,false (ornever) orauto (ortrue), in which case colors are usedonly when the output is to a terminal. If unset, then thevalue ofcolor.ui is used (auto by default).

color.branch.<slot>

Use customized color for branch coloration.<slot> is one ofcurrent (the current branch),local (a local branch),remote (a remote-tracking branch in refs/remotes/),upstream (upstream tracking branch),plain (otherrefs).

color.diff

Whether to use ANSI escape sequences to add color to patches.If this is set toalways,git-diff(1),git-log(1), andgit-show(1) will use colorfor all patches. If it is set totrue orauto, thosecommands will only use color when output is to the terminal.If unset, then the value ofcolor.ui is used (auto bydefault).

This does not affectgit-format-patch(1) or thegit-diff-* plumbing commands. Can be overridden on thecommand line with the--color[=<when>] option.

color.diff.<slot>

Use customized color for diff colorization.<slot> specifieswhich part of the patch to use the specified color, and is oneofcontext (context text -plain is a historical synonym),meta (metainformation),frag(hunk header),func (function in hunk header),old (removed lines),new (added lines),commit (commit headers),whitespace(highlighting whitespace errors),oldMoved (deleted lines),newMoved (added lines),oldMovedDimmed,oldMovedAlternative,oldMovedAlternativeDimmed,newMovedDimmed,newMovedAlternativenewMovedAlternativeDimmed (See the<mode>setting of--color-moved ingit-diff(1) for details),contextDimmed,oldDimmed,newDimmed,contextBold,oldBold, andnewBold (seegit-range-diff(1) for details).

color.decorate.<slot>

Use customized color forgit log --decorate output.<slot> is oneofbranch,remoteBranch,tag,stash orHEAD for localbranches, remote-tracking branches, tags, stash and HEAD, respectivelyandgrafted for grafted commits.

color.grep

When set toalways, always highlight matches. Whenfalse (ornever), never. When set totrue orauto, use color onlywhen the output is written to the terminal. If unset, then thevalue ofcolor.ui is used (auto by default).

color.grep.<slot>

Use customized color for grep colorization.<slot> specifies whichpart of the line to use the specified color, and is one of

context

non-matching text in context lines (when using-A,-B, or-C)

filename

filename prefix (when not using-h)

function

function name lines (when using-p)

lineNumber

line number prefix (when using-n)

column

column number prefix (when using--column)

match

matching text (same as settingmatchContext andmatchSelected)

matchContext

matching text in context lines

matchSelected

matching text in selected lines. Also, used to customize the followinggit-log(1) subcommands:--grep,--author, and--committer.

selected

non-matching text in selected lines. Also, used to customize thefollowinggit-log(1) subcommands:--grep,--author and--committer.

separator

separators between fields on a line (:,-, and=)and between hunks (--)

color.interactive

When set toalways, always use colors for interactive promptsand displays (such as those used by "git-add --interactive" and"git-clean --interactive"). When false (ornever), never.When set totrue orauto, use colors only when the output isto the terminal. If unset, then the value ofcolor.ui isused (auto by default).

color.interactive.<slot>

Use customized color forgit add --interactive andgit clean--interactive output.<slot> may beprompt,header,helporerror, for four distinct types of normal output frominteractive commands.

color.pager

A boolean to specify whetherauto color modes should colorizeoutput going to the pager. Defaults to true; set this to falseif your pager does not understand ANSI color codes.

color.push

A boolean to enable/disable color in push errors. May be set toalways,false (ornever) orauto (ortrue), in whichcase colors are used only when the error output goes to a terminal.If unset, then the value ofcolor.ui is used (auto by default).

color.push.error

Use customized color for push errors.

color.remote

If set, keywords at the start of the line are highlighted. Thekeywords are "error", "warning", "hint" and "success", and arematched case-insensitively. May be set toalways,false (ornever) orauto (ortrue). If unset, then the value ofcolor.ui is used (auto by default).

color.remote.<slot>

Use customized color for each remote keyword.<slot> may behint,warning,success orerror which match thecorresponding keyword.

color.showBranch

A boolean to enable/disable color in the output ofgit-show-branch(1). May be set toalways,false (ornever) orauto (ortrue), in which case colors are usedonly when the output is to a terminal. If unset, then thevalue ofcolor.ui is used (auto by default).

color.status

A boolean to enable/disable color in the output ofgit-status(1). May be set toalways,false (ornever) orauto (ortrue), in which case colors are usedonly when the output is to a terminal. If unset, then thevalue ofcolor.ui is used (auto by default).

color.status.<slot>

Use customized color for status colorization.<slot> isone ofheader (the header text of the status message),added orupdated (files which are added but not committed),changed (files which are changed but not added in the index),untracked (files which are not tracked by Git),branch (the current branch),nobranch (the color theno branch warning is shown in, defaultingto red),localBranch orremoteBranch (the local and remote branch names,respectively, when branch and tracking information is displayed in thestatus short-format), orunmerged (files which have unmerged changes).

color.transport

A boolean to enable/disable color when pushes are rejected. May beset toalways,false (ornever) orauto (ortrue), in whichcase colors are used only when the error output goes to a terminal.If unset, then the value ofcolor.ui is used (auto by default).

color.transport.rejected

Use customized color when a push was rejected.

color.ui

This variable determines the default value for variables suchascolor.diff andcolor.grep that control the use of colorper command family. Its scope will expand as more commands learnconfiguration to set a default for the--color option. Set ittofalse ornever if you prefer Git commands not to usecolor unless enabled explicitly with some other configurationor the--color option. Set it toalways if you want alloutput not intended for machine consumption to use color, totrue orauto (this is the default since Git 1.8.4) if youwant such output to use color when written to the terminal.

column.ui

Specify whether supported commands should output in columns.This variable consists of a list of tokens separated by spacesor commas:

These options control when the feature should be enabled(defaults tonever):

always

always show in columns

never

never show in columns

auto

show in columns if the output is to the terminal

These options control layout (defaults tocolumn). Setting anyof these impliesalways if none ofalways,never, orauto arespecified.

column

fill columns before rows

row

fill rows before columns

plain

show in one column

Finally, these options can be combined with a layout option (defaultstonodense):

dense

make unequal size columns to utilize more space

nodense

make equal size columns

column.branch

Specify whether to output branch listing ingitbranch in columns.Seecolumn.ui for details.

column.clean

Specify the layout when listing items ingitclean-i, which alwaysshows files and directories in columns. Seecolumn.ui for details.

column.status

Specify whether to output untracked files ingitstatus in columns.Seecolumn.ui for details.

column.tag

Specify whether to output tag listings ingittag in columns.Seecolumn.ui for details.

commit.cleanup

This setting overrides the default of the--cleanup option ingitcommit. Seegit-commit(1) for details. Changing the default can be usefulwhen you always want to keep lines that beginwith the comment character (core.commentChar, default #)in your log message, in which case youwould dogitconfigcommit.cleanupwhitespace (note that you willhave to remove the help lines that begin with the comment characterin the commit log template yourself, if you do this).

commit.gpgSign

A boolean to specify whether all commits should be GPG signed.Use of this option when doing operations such as rebase canresult in a large number of commits being signed. It may beconvenient to use an agent to avoid typing your GPG passphraseseveral times.

commit.status

A boolean to enable/disable inclusion of status information in thecommit message template when using an editor to prepare the commitmessage. Defaults totrue.

commit.template

Specify the pathname of a file to use as the template fornew commit messages.

commit.verbose

A boolean or int to specify the level of verbosity withgitcommit.Seegit-commit(1) for details.

commitGraph.generationVersion

Specifies the type of generation number version to use when writingor reading the commit-graph file. If version 1 is specified, thenthe corrected commit dates will not be written or read. Defaults to2.

commitGraph.maxNewFilters

Specifies the default value for the--max-new-filters option ofgitcommit-graphwrite (c.f.,git-commit-graph(1)).

commitGraph.changedPaths

If true, thengitcommit-graphwrite will compute and writechanged-path Bloom filters by default, equivalent to passing--changed-paths. If false or unset, changed-paths Bloom filters willbe written duringgitcommit-graphwrite only if the filters alreadyexist in the current commit-graph file. This matches the defaultbehavior ofgitcommit-graphwrite without any--[no-]changed-pathsoption. To rewrite a commit-graph file without any filters, use the--no-changed-paths option. Command-line option--[no-]changed-pathsalways takes precedence over this configuration. Defaults to unset.

commitGraph.readChangedPaths

Deprecated. Equivalent to commitGraph.changedPathsVersion=-1 if true, andcommitGraph.changedPathsVersion=0 if false. (If commitGraph.changedPathVersionis also set, commitGraph.changedPathsVersion takes precedence.)

commitGraph.changedPathsVersion

Specifies the version of the changed-path Bloom filters that Git will read andwrite. May be -1, 0, 1, or 2. Note that values greater than 1 may beincompatible with older versions of Git which do not yet understandthose versions. Use caution when operating in a mixed-versionenvironment.

Defaults to -1.

If -1, Git will use the version of the changed-path Bloom filters in therepository, defaulting to 1 if there are none.

If 0, Git will not read any Bloom filters, and will write version 1 Bloomfilters when instructed to write.

If 1, Git will only read version 1 Bloom filters, and will write version 1Bloom filters.

If 2, Git will only read version 2 Bloom filters, and will write version 2Bloom filters.

Seegit-commit-graph(1) for more information.

completion.commands

This is only used by git-completion.bash to add or removecommands from the list of completed commands. Normally onlyporcelain commands and a few select others are completed. Youcan add more commands, separated by space, in thisvariable. Prefixing the command with- will remove it fromthe existing list.

core.fileMode

Tells Git if the executable bit of files in the working treeis to be honored.

Some filesystems lose the executable bit when a file that ismarked as executable is checked out, or checks out anon-executable file with executable bit on.git-clone(1) orgit-init(1) probe the filesystemto see if it handles the executable bit correctlyand this variable is automatically set as necessary.

A repository, however, may be on a filesystem that handlesthe filemode correctly, and this variable is set totruewhen created, but later may be made accessible from anotherenvironment that loses the filemode (e.g. exporting ext4 viaCIFS mount, visiting a Cygwin created repository withGit for Windows or Eclipse).In such a case it may be necessary to set this variable tofalse.Seegit-update-index(1).

The default is true (when core.filemode is not specified in the config file).

core.hideDotFiles

(Windows-only) If true, mark newly-created directories and files whosename starts with a dot as hidden. IfdotGitOnly, only the .git/directory is hidden, but no other files starting with a dot. Thedefault mode isdotGitOnly.

core.ignoreCase

Internal variable which enables various workarounds to enableGit to work better on filesystems that are not case sensitive,like APFS, HFS+, FAT, NTFS, etc. For example, if a directory listingfinds "makefile" when Git expects "Makefile", Git will assumeit is really the same file, and continue to remember it as"Makefile".

The default is false, exceptgit-clone(1) orgit-init(1)will probe and set core.ignoreCase true if appropriate when the repositoryis created.

Git relies on the proper configuration of this variable for your operatingand file system. Modifying this value may result in unexpected behavior.

core.precomposeUnicode

This option is only used by Mac OS implementation of Git.When core.precomposeUnicode=true, Git reverts the unicode decompositionof filenames done by Mac OS. This is useful when sharing a repositorybetween Mac OS and Linux or Windows.(Git for Windows 1.7.10 or higher is needed, or Git under cygwin 1.7).When false, file names are handled fully transparent by Git,which is backward compatible with older versions of Git.

core.protectHFS

If set to true, do not allow checkout of paths that wouldbe considered equivalent to .git on an HFS+ filesystem.Defaults totrue on Mac OS, andfalse elsewhere.

core.protectNTFS

If set to true, do not allow checkout of paths that wouldcause problems with the NTFS filesystem, e.g. conflict with8.3 "short" names.Defaults totrue on Windows, andfalse elsewhere.

core.fsmonitor

If set to true, enable the built-in file system monitordaemon for this working directory (git-fsmonitor--daemon(1)).

Like hook-based file system monitors, the built-in file system monitorcan speed up Git commands that need to refresh the Git index(e.g.gitstatus) in a working directory with many files. Thebuilt-in monitor eliminates the need to install and maintain anexternal third-party tool.

The built-in file system monitor is currently available only on alimited set of supported platforms. Currently, this includes Windowsand MacOS.

Otherwise, this variable contains the pathname of the "fsmonitor"hook command.

This hook command is used to identify all files that may have changedsince the requested date/time. This information is used to speed upgit by avoiding unnecessary scanning of files that have not changed.

See the "fsmonitor-watchman" section ofgithooks(5).

Note that if you concurrently use multiple versions of Git, suchas one version on the command line and another version in an IDEtool, that the definition ofcore.fsmonitor was extended toallow boolean values in addition to hook pathnames. Git versions2.35.1 and prior will not understand the boolean values and willconsider the "true" or "false" values as hook pathnames to beinvoked. Git versions 2.26 thru 2.35.1 default to hook protocolV2 and will fall back to no fsmonitor (full scan). Git versionsprior to 2.26 default to hook protocol V1 and will silentlyassume there were no changes to report (no scan), so statuscommands may report incomplete results. For this reason, it isbest to upgrade all of your Git versions before using the built-infile system monitor.

core.fsmonitorHookVersion

Sets the protocol version to be used when invoking the"fsmonitor" hook.

There are currently versions 1 and 2. When this is not set,version 2 will be tried first and if it fails then version 1will be tried. Version 1 uses a timestamp as input to determinewhich files have changes since that time but some monitorslike Watchman have race conditions when used with a timestamp.Version 2 uses an opaque string so that the monitor can returnsomething that can be used to determine what files have changedwithout race conditions.

core.trustctime

If false, the ctime differences between the index and theworking tree are ignored; useful when the inode change timeis regularly modified by something outside Git (file systemcrawlers and some backup systems).Seegit-update-index(1). True by default.

core.splitIndex

If true, the split-index feature of the index will be used.Seegit-update-index(1). False by default.

core.untrackedCache

Determines what to do about the untracked cache feature of theindex. It will be kept, if this variable is unset or set tokeep. It will automatically be added if set totrue. Andit will automatically be removed, if set tofalse. Beforesetting it totrue, you should check that mtime is workingproperly on your system.Seegit-update-index(1).keep by default, unlessfeature.manyFiles is enabled which sets this setting totrue by default.

core.checkStat

When missing or is set todefault, many fields in the statstructure are checked to detect if a file has been modifiedsince Git looked at it. When this configuration variable isset tominimal, sub-second part of mtime and ctime, theuid and gid of the owner of the file, the inode number (andthe device number, if Git was compiled to use it), areexcluded from the check among these fields, leaving only thewhole-second part of mtime (and ctime, ifcore.trustCtimeis set) and the filesize to be checked.

There are implementations of Git that do not leave usable values insome fields (e.g. JGit); by excluding these fields from thecomparison, theminimal mode may help interoperability when thesame repository is used by these other systems at the same time.

core.quotePath

Commands that output paths (e.g.ls-files,diff), willquote "unusual" characters in the pathname by enclosing thepathname in double-quotes and escaping those characters withbackslashes in the same way C escapes control characters (e.g.\t for TAB,\n for LF,\\ for backslash) or bytes withvalues larger than 0x80 (e.g. octal\302\265 for "micro" inUTF-8). If this variable is set to false, bytes higher than0x80 are not considered "unusual" any more. Double-quotes,backslash and control characters are always escaped regardlessof the setting of this variable. A simple space character isnot considered "unusual". Many commands can output pathnamescompletely verbatim using the-z option. The default valueis true.

core.eol

Sets the line ending type to use in the working directory forfiles that are marked as text (either by having thetextattribute set, or by havingtext=auto and Git auto-detectingthe contents as text).Alternatives arelf,crlf andnative, which uses the platform’snative line ending. The default value isnative. Seegitattributes(5) for more information on end-of-lineconversion. Note that this value is ignored ifcore.autocrlfis set totrue orinput.

core.safecrlf

If true, makes Git check if convertingCRLF is reversible whenend-of-line conversion is active. Git will verify if a commandmodifies a file in the work tree either directly or indirectly.For example, committing a file followed by checking out thesame file should yield the original file in the work tree. Ifthis is not the case for the current setting ofcore.autocrlf, Git will reject the file. The variable canbe set to "warn", in which case Git will only warn about anirreversible conversion but continue the operation.

CRLF conversion bears a slight chance of corrupting data.When it is enabled, Git will convert CRLF to LF during commit and LF toCRLF during checkout. A file that contains a mixture of LF andCRLF before the commit cannot be recreated by Git. For textfiles this is the right thing to do: it corrects line endingssuch that we have only LF line endings in the repository.But for binary files that are accidentally classified as text theconversion can corrupt data.

If you recognize such corruption early you can easily fix it bysetting the conversion type explicitly in .gitattributes. Rightafter committing you still have the original file in your worktree and this file is not yet corrupted. You can explicitly tellGit that this file is binary and Git will handle the fileappropriately.

Unfortunately, the desired effect of cleaning up text files withmixed line endings and the undesired effect of corrupting binaryfiles cannot be distinguished. In both cases CRLFs are removedin an irreversible way. For text files this is the right thingto do because CRLFs are line endings, while for binary filesconverting CRLFs corrupts data.

Note, this safety check does not mean that a checkout will generate afile identical to the original file for a different setting ofcore.eol andcore.autocrlf, but only for the current one. Forexample, a text file withLF would be accepted withcore.eol=lfand could later be checked out withcore.eol=crlf, in which case theresulting file would containCRLF, although the original filecontainedLF. However, in both work trees the line endings would beconsistent, that is either allLF or allCRLF, but never mixed. Afile with mixed line endings would be reported by thecore.safecrlfmechanism.

core.autocrlf

Setting this variable to "true" is the same as settingthetext attribute to "auto" on all files and core.eol to "crlf".Set to true if you want to haveCRLF line endings in yourworking directory and the repository has LF line endings.This variable can be set toinput,in which case no output conversion is performed.

core.checkRoundtripEncoding

A comma and/or whitespace separated list of encodings that Gitperforms UTF-8 round trip checks on if they are used in anworking-tree-encoding attribute (seegitattributes(5)).The default value isSHIFT-JIS.

core.symlinks

If false, symbolic links are checked out as small plain files thatcontain the link text.git-update-index(1) andgit-add(1) will not change the recorded type to regularfile. Useful on filesystems like FAT that do not supportsymbolic links.

The default is true, exceptgit-clone(1) orgit-init(1)will probe and set core.symlinks false if appropriate when the repositoryis created.

core.gitProxy

A "proxy command" to execute (ascommand host port) insteadof establishing direct connection to the remote server whenusing the Git protocol for fetching. If the variable value isin the "COMMAND for DOMAIN" format, the command is applied onlyon hostnames ending with the specified domain string. This variablemay be set multiple times and is matched in the given order;the first match wins.

Can be overridden by theGIT_PROXY_COMMAND environment variable(which always applies universally, without the special "for"handling).

The special stringnone can be used as the proxy command tospecify that no proxy be used for a given domain pattern.This is useful for excluding servers inside a firewall fromproxy use, while defaulting to a common proxy for external domains.

core.sshCommand

If this variable is set,gitfetch andgitpush willuse the specified command instead ofssh when they need toconnect to a remote system. The command is in the same form astheGIT_SSH_COMMAND environment variable and is overriddenwhen the environment variable is set.

core.ignoreStat

If true, Git will avoid using lstat() calls to detect if files havechanged by setting the "assume-unchanged" bit for those tracked fileswhich it has updated identically in both the index and working tree.

When files are modified outside of Git, the user will need to stagethe modified files explicitly (e.g. seeExamples section ingit-update-index(1)).Git will not normally detect changes to those files.

This is useful on systems where lstat() calls are very slow, such asCIFS/Microsoft Windows.

False by default.

core.preferSymlinkRefs

Instead of the default "symref" format for HEADand other symbolic reference files, use symbolic links.This is sometimes needed to work with old scripts thatexpect HEAD to be a symbolic link.

This configuration is deprecated and will be removed in Git 3.0. Symbolic refswill always be written as textual symrefs.

core.alternateRefsCommand

When advertising tips of available history from an alternate, use the shell toexecute the specified command instead ofgit-for-each-ref(1). Thefirst argument is the absolute path of the alternate. Output must contain onehex object id per line (i.e., the same as produced bygitfor-each-ref--format='%(objectname)').

Note that you cannot generally putgitfor-each-ref directly into the configvalue, as it does not take a repository path as an argument (but you can wrapthe command above in a shell script).

core.alternateRefsPrefixes

When listing references from an alternate, list only references that beginwith the given prefix. Prefixes match as if they were given as arguments togit-for-each-ref(1). To list multiple prefixes, separate them withwhitespace. Ifcore.alternateRefsCommand is set, settingcore.alternateRefsPrefixes has no effect.

core.bare

If true this repository is assumed to bebare and has noworking directory associated with it. If this is the case anumber of commands that require a working directory will bedisabled, such asgit-add(1) orgit-merge(1).

This setting is automatically guessed bygit-clone(1) orgit-init(1) when the repository was created. By default arepository that ends in "/.git" is assumed to be not bare (bare =false), while all other repositories are assumed to be bare (bare= true).

core.worktree

Set the path to the root of the working tree.IfGIT_COMMON_DIR environment variable is set, core.worktreeis ignored and not used for determining the root of working tree.This can be overridden by theGIT_WORK_TREE environmentvariable and the--work-tree command-line option.The value can be an absolute path or relative to the path tothe .git directory, which is either specified by --git-diror GIT_DIR, or automatically discovered.If --git-dir or GIT_DIR is specified but none of--work-tree, GIT_WORK_TREE and core.worktree is specified,the current working directory is regarded as the top levelof your working tree.

Note that this variable is honored even when set in a configurationfile in a ".git" subdirectory of a directory and its value differsfrom the latter directory (e.g. "/path/to/.git/config" hascore.worktree set to "/different/path"), which is most likely amisconfiguration. Running Git commands in the "/path/to" directory willstill use "/different/path" as the root of the work tree and can causeconfusion unless you know what you are doing (e.g. you are creating aread-only snapshot of the same index to a location different from therepository’s usual working tree).

core.logAllRefUpdates

Enable the reflog. Updates to a ref <ref> is logged to the file"$GIT_DIR/logs/<ref>", by appending the new and oldSHA-1, the date/time and the reason of the update, butonly when the file exists. If this configurationvariable is set totrue, missing "$GIT_DIR/logs/<ref>"file is automatically created for branch heads (i.e. underrefs/heads/), remote refs (i.e. underrefs/remotes/),note refs (i.e. underrefs/notes/), and the symbolic refHEAD.If it is set toalways, then a missing reflog is automaticallycreated for any ref underrefs/.

This information can be used to determine what commitwas the tip of a branch "2 days ago".

This value is true by default in a repository that hasa working directory associated with it, and false bydefault in a bare repository.

core.repositoryFormatVersion

Internal variable identifying the repository format and layoutversion. Seegitrepository-layout(5).

core.sharedRepository

Whengroup (ortrue), the repository is made shareable betweenseveral users in a group (making sure all the files and objects aregroup-writable). Whenall (orworld oreverybody), therepository will be readable by all users, additionally to beinggroup-shareable. Whenumask (orfalse), Git will use permissionsreported by umask(2). When0xxx, where0xxx is an octal number,files in the repository will have this mode value.0xxx will overrideuser’s umask value (whereas the other options will only overriderequested parts of the user’s umask value). Examples:0660 will makethe repo read/write-able for the owner and group, but inaccessible toothers (equivalent togroup unless umask is e.g.0022).0640 is arepository that is group-readable but not group-writable.Seegit-init(1). False by default.

core.warnAmbiguousRefs

If true, Git will warn you if the ref name you passed it is ambiguousand might match multiple refs in the repository. True by default.

core.compression

An integer -1..9, indicating a default compression level.-1 is the zlib default. 0 means no compression,and 1..9 are various speed/size tradeoffs, 9 being slowest.If set, this provides a default to other compression variables,such ascore.looseCompression andpack.compression.

core.looseCompression

An integer -1..9, indicating the compression level for objects thatare not in a pack file. -1 is the zlib default. 0 means nocompression, and 1..9 are various speed/size tradeoffs, 9 beingslowest. If not set, defaults to core.compression. If that isnot set, defaults to 1 (best speed).

core.packedGitWindowSize

Number of bytes of a pack file to map into memory in asingle mapping operation. Larger window sizes may allowyour system to process a smaller number of large pack filesmore quickly. Smaller window sizes will negatively affectperformance due to increased calls to the operating system’smemory manager, but may improve performance when accessinga large number of large pack files.

Default is 1 MiB if NO_MMAP was set at compile time, otherwise 32MiB on 32 bit platforms and 1 GiB on 64 bit platforms. This shouldbe reasonable for all users/operating systems. You probably donot need to adjust this value.

Common unit suffixes ofk,m, org are supported.

core.packedGitLimit

Maximum number of bytes to map simultaneously into memoryfrom pack files. If Git needs to access more than this manybytes at once to complete an operation it will unmap existingregions to reclaim virtual address space within the process.

Default is 256 MiB on 32 bit platforms and 32 TiB (effectivelyunlimited) on 64 bit platforms.This should be reasonable for all users/operating systems, except onthe largest projects. You probably do not need to adjust this value.

Common unit suffixes ofk,m, org are supported.

core.deltaBaseCacheLimit

Maximum number of bytes per thread to reserve for caching base objectsthat may be referenced by multiple deltified objects. By storing theentire decompressed base objects in a cache Git is ableto avoid unpacking and decompressing frequently used baseobjects multiple times.

Default is 96 MiB on all platforms. This should be reasonablefor all users/operating systems, except on the largest projects.You probably do not need to adjust this value.

Common unit suffixes ofk,m, org are supported.

core.bigFileThreshold

The size of files considered "big", which as discussed belowchanges the behavior of numerous git commands, as well as howsuch files are stored within the repository. The default is512 MiB. Common unit suffixes ofk,m, org aresupported.

Files above the configured limit will be:

• Stored deflated in packfiles, without attempting delta compression.

  The default limit is primarily set with this use-case in mind. With it,most projects will have their source code and other text files deltacompressed, but not larger binary media files.

  Storing large files without delta compression avoids excessive memoryusage, at the slight expense of increased disk usage.

• Will be treated as if they were labeled "binary" (seegitattributes(5)). e.g.git-log(1) andgit-diff(1) will not compute diffs for files above this limit.

• Will generally be streamed when written, which avoids excessivememory usage, at the cost of some fixed overhead. Commands that makeuse of this includegit-archive(1),git-fast-import(1),git-index-pack(1),git-unpack-objects(1) andgit-fsck(1).

core.excludesFile

Specifies the pathname to the file that contains patterns todescribe paths that are not meant to be tracked, in additionto .gitignore (per-directory) and .git/info/exclude.Defaults to$XDG_CONFIG_HOME/git/ignore.If$XDG_CONFIG_HOME is either not set or empty,$HOME/.config/git/ignoreis used instead. Seegitignore(5).

core.askPass

Some commands (e.g. svn and http interfaces) that interactivelyask for a password can be told to use an external program givenvia the value of this variable. Can be overridden by theGIT_ASKPASSenvironment variable. If not set, fall back to the value of theSSH_ASKPASS environment variable or, failing that, a simple passwordprompt. The external program shall be given a suitable prompt ascommand-line argument and write the password on its STDOUT.

core.attributesFile

In addition to .gitattributes (per-directory) and.git/info/attributes, Git looks into this file for attributes(seegitattributes(5)). Path expansions are made the sameway as forcore.excludesFile. Its default value is$XDG_CONFIG_HOME/git/attributes. If$XDG_CONFIG_HOME is either notset or empty,$HOME/.config/git/attributes is used instead.

core.hooksPath

By default Git will look for your hooks in the$GIT_DIR/hooks directory. Set this to different path,e.g./etc/git/hooks, and Git will try to find your hooks inthat directory, e.g./etc/git/hooks/pre-receive instead ofin$GIT_DIR/hooks/pre-receive.

The path can be either absolute or relative. A relative path istaken as relative to the directory where the hooks are run (seethe "DESCRIPTION" section ofgithooks(5)).

This configuration variable is useful in cases where you’d like tocentrally configure your Git hooks instead of configuring them on aper-repository basis, or as a more flexible and centralizedalternative to having aninit.templateDir where you’ve changeddefault hooks.

You can also disable all hooks entirely by settingcore.hooksPathto/dev/null. This is usually only advisable for expert users andon a per-command basis using configuration parameters of the formgit-ccore.hooksPath=/dev/null ....

core.editor

Commands such ascommit andtag that let you editmessages by launching an editor use the value of thisvariable when it is set, and the environment variableGIT_EDITOR is not set. Seegit-var(1).

core.commentChar

core.commentString

Commands such ascommit andtag that let you editmessages consider a line that begins with this charactercommented, and removes them after the editor returns(default#).

If set to "auto",git-commit will select a character that is notthe beginning character of any line in existing commit messages.Support for this value is deprecated and will be removed in Git 3.0due to the following limitations:

• It is incompatible with adding comments in a commit messagetemplate. This includes the conflicts comments added tothe commit message bycherry-pick,merge,rebase andrevert.

• It is incompatible with adding comments to the commit messagein theprepare-commit-msg hook.

• It is incompatible with thefixup andsquash commands whenrebasing,

• It is not respected bygitnotes

Note that these two variables are aliases of each other, and in modernversions of Git you are free to use a string (e.g.,// or ⁑⁕⁑) withcommentChar. Versions of Git prior to v2.45.0 will ignorecommentString but will reject a value ofcommentChar that consistsof more than a single ASCII byte. If you plan to use your config witholder and newer versions of Git, you may want to specify both:

[core]# single character for older versionscommentChar = "#"# string for newer versions (which will override commentChar# because it comes later in the file)commentString = "//"

core.filesRefLockTimeout

The length of time, in milliseconds, to retry when trying tolock an individual reference. Value 0 means not to retry atall; -1 means to try indefinitely. Default is 100 (i.e.,retry for 100ms).

core.packedRefsTimeout

The length of time, in milliseconds, to retry when trying tolock thepacked-refs file. Value 0 means not to retry atall; -1 means to try indefinitely. Default is 1000 (i.e.,retry for 1 second).

core.pager

Text viewer for use by Git commands (e.g.,less). The valueis meant to be interpreted by the shell. The order of preferenceis the$GIT_PAGER environment variable, thencore.pagerconfiguration, then$PAGER, and then the default chosen atcompile time (usuallyless).

When theLESS environment variable is unset, Git sets it toFRX(ifLESS environment variable is set, Git does not change it atall). If you want to selectively override Git’s default settingforLESS, you can setcore.pager to e.g.less-S. This willbe passed to the shell by Git, which will translate the finalcommand toLESS=FRXless-S. The environment does not set theS option but the command line does, instructing less to truncatelong lines. Similarly, settingcore.pager toless-+F willdeactivate theF option specified by the environment from thecommand-line, deactivating the "quit if one screen" behavior ofless. One can specifically activate some flags for particularcommands: for example, settingpager.blame toless-S enablesline truncation only forgitblame.

Likewise, when theLV environment variable is unset, Git sets itto-c. You can override this setting by exportingLV withanother value or settingcore.pager tolv+c.

core.whitespace

A comma separated list of common whitespace problems tonotice.git diff will usecolor.diff.whitespace tohighlight them, andgit apply --whitespace=error willconsider them as errors. You can prefix- to disableany of them (e.g.-trailing-space):

• blank-at-eol treats trailing whitespaces at the end of the lineas an error (enabled by default).

• space-before-tab treats a space character that appears immediatelybefore a tab character in the initial indent part of the line as anerror (enabled by default).

• indent-with-non-tab treats a line that is indented with spacecharacters instead of the equivalent tabs as an error (not enabled bydefault).

• tab-in-indent treats a tab character in the initial indent part ofthe line as an error (not enabled by default).

• blank-at-eof treats blank lines added at the end of file as an error(enabled by default).

• trailing-space is a short-hand to cover bothblank-at-eol andblank-at-eof.

• cr-at-eol treats a carriage-return at the end of line aspart of the line terminator, i.e. with it,trailing-spacedoes not trigger if the character before such a carriage-returnis not a whitespace (not enabled by default).

• tabwidth=<n> tells how many character positions a tab occupies; thisis relevant forindent-with-non-tab and when Git fixestab-in-indenterrors. The default tab width is 8. Allowed values are 1 to 63.

core.fsync

A comma-separated list of components of the repository thatshould be hardened via the core.fsyncMethod when created ormodified. You can disable hardening of any component byprefixing it with a-. Items that are not hardened may belost in the event of an uncleansystem shutdown. Unless youhave special requirements, it is recommended that you leavethis option empty or pick one ofcommitted,added,orall.

When this configuration is encountered, the set of components starts withthe platform default value, disabled components are removed, and additionalcomponents are added.none resets the state so that the platform defaultis ignored.

The empty string resets the fsync configuration to the platformdefault. The default on most platforms is equivalent tocore.fsync=committed,-loose-object, which has good performance,but risks losing recent work in the event of an unclean system shutdown.

• none clears the set of fsynced components.

• loose-object hardens objects added to the repo in loose-object form.

• pack hardens objects added to the repo in packfile form.

• pack-metadata hardens packfile bitmaps and indexes.

• commit-graph hardens the commit-graph file.

• index hardens the index when it is modified.

• objects is an aggregate option that is equivalent toloose-object,pack.

• reference hardens references modified in the repo.

• derived-metadata is an aggregate option that is equivalent topack-metadata,commit-graph.

• committed is an aggregate option that is currently equivalent toobjects. This mode sacrifices some performance to ensure that workthat is committed to the repository withgitcommit or similar commandsis hardened.

• added is an aggregate option that is currently equivalent tocommitted,index. This mode sacrifices additional performance toensure that the results of commands likegitadd and similar operationsare hardened.

• all is an aggregate option that syncs all individual components above.

core.fsyncMethod

A value indicating the strategy Git will use to harden repository datausing fsync and related primitives.

• fsync uses the fsync() system call or platform equivalents.

• writeout-only issues pagecache writeback requests, but depending on thefilesystem and storage hardware, data added to the repository may not bedurable in the event of a system crash. This is the default mode on macOS.

• batch enables a mode that uses writeout-only flushes to stage multipleupdates in the disk writeback cache and then does a single full fsync ofa dummy file to trigger the disk cache flush at the end of the operation.

  Currentlybatch mode only applies to loose-object files. Other repositorydata is made durable as iffsync was specified. This mode is expected tobe as safe asfsync on macOS for repos stored on HFS+ or APFS filesystemsand on Windows for repos stored on NTFS or ReFS filesystems.

core.fsyncObjectFiles

This boolean will enablefsync() when writing object files.This setting is deprecated. Use core.fsync instead.

This setting affects data added to the Git repository in loose-objectform. When set to true, Git will issue an fsync or similar system callto flush caches so that loose-objects remain consistent in the faceof a unclean system shutdown.

core.preloadIndex

Enable parallel index preload for operations likegit diff

This can speed up operations likegit diff andgit status especiallyon filesystems like NFS that have weak caching semantics and thusrelatively high IO latencies. When enabled, Git will do theindex comparison to the filesystem data in parallel, allowingoverlapping IO’s. Defaults to true.

core.unsetenvvars

Windows-only: comma-separated list of environment variables'names that need to be unset before spawning any other process.Defaults toPERL5LIB to account for the fact that Git forWindows insists on using its own Perl interpreter.

core.createObject

You can set this tolink, in which case a hardlink followed bya delete of the source are used to make sure that object creationwill not overwrite existing objects.

On some file system/operating system combinations, this is unreliable.Set this config setting torename there; however, this will remove thecheck that makes sure that existing object files will not get overwritten.

core.notesRef

When showing commit messages, also show notes which are stored inthe given ref. The ref must be fully qualified. If the givenref does not exist, it is not an error but means that nonotes should be printed.

This setting defaults to "refs/notes/commits", and it can be overridden bytheGIT_NOTES_REF environment variable. Seegit-notes(1).

core.commitGraph

If true, then git will read the commit-graph file (if it exists)to parse the graph structure of commits. Defaults to true. Seegit-commit-graph(1) for more information.

core.useReplaceRefs

If set tofalse, behave as if the--no-replace-objectsoption was given on the command line. Seegit(1) andgit-replace(1) for more information.

core.multiPackIndex

Use the multi-pack-index file to track multiple packfiles using asingle index. Seegit-multi-pack-index(1) for moreinformation. Defaults to true.

core.sparseCheckout

Enable "sparse checkout" feature. Seegit-sparse-checkout(1)for more information.

core.sparseCheckoutCone

Enables the "cone mode" of the sparse checkout feature. When thesparse-checkout file contains a limited set of patterns, thismode provides significant performance advantages. The "non-conemode" can be requested to allow specifying more flexiblepatterns by setting this variable tofalse. Seegit-sparse-checkout(1) for more information.

core.abbrev

Set the length object names are abbreviated to. Ifunspecified or set to "auto", an appropriate value iscomputed based on the approximate number of packed objectsin your repository, which hopefully is enough forabbreviated object names to stay unique for some time.If set to "no", no abbreviation is made and the object namesare shown in their full length.The minimum length is 4.

core.maxTreeDepth

The maximum depth Git is willing to recurse while traversing atree (e.g., "a/b/cde/f" has a depth of 4). This is a fail-safeto allow Git to abort cleanly, and should not generally need tobe adjusted. When Git is compiled with MSVC, the default is 512.Otherwise, the default is 2048.

credential.helper

Specify an external helper to be called when a username orpassword credential is needed; the helper may consult externalstorage to avoid prompting the user for the credentials. This isnormally the name of a credential helper with possiblearguments, but may also be an absolute path with arguments or, ifpreceded by !, shell commands.

Note that multiple helpers may be defined. Seegitcredentials(7)for details and examples.

credential.interactive

By default, Git and any configured credential helpers will ask foruser input when new credentials are required. Many of these helperswill succeed based on stored credentials if those credentials arestill valid. To avoid the possibility of user interactivity fromGit, setcredential.interactive=false. Some credential helpersrespect this option as well.

credential.useHttpPath

When acquiring credentials, consider the "path" component of an httpor https URL to be important. Defaults to false. Seegitcredentials(7) for more information.

credential.sanitizePrompt

By default, user names and hosts that are shown as part of thepassword prompt are not allowed to contain control characters (theywill be URL-encoded by default). Configure this setting tofalse tooverride that behavior.

credential.protectProtocol

By default, Carriage Return characters are not allowed in the protocolthat is used when Git talks to a credential helper. This setting allowsusers to override this default.

credential.username

If no username is set for a network authentication, use this usernameby default. See credential.<context>.* below, andgitcredentials(7).

credential.<url>.*

Any of the credential.* options above can be applied selectively tosome credentials. For example, "credential.https://example.com.username"would set the default username only for https connections toexample.com. Seegitcredentials(7) for details on how URLs arematched.

credentialCache.ignoreSIGHUP

Tell git-credential-cache—​daemon to ignore SIGHUP, instead of quitting.

credentialStore.lockTimeoutMS

The length of time, in milliseconds, for git-credential-store to retrywhen trying to lock the credentials file. A value of 0 means not to retry atall; -1 means to try indefinitely. Default is 1000 (i.e., retry for1s).

diff.autoRefreshIndex

When usinggitdiff to compare with work treefiles, do not consider stat-only changes as changed.Instead, silently rungitupdate-index--refresh toupdate the cached stat information for paths whosecontents in the work tree match the contents in theindex. This option defaults totrue. Note that thisaffects onlygitdiff Porcelain, and not lower leveldiff commands such asgitdiff-files.

diff.dirstat

A comma separated list of--dirstat parameters specifying thedefault behavior of the--dirstat option togit-diff(1)and friends.The defaults can be overridden on the command line(using--dirstat=<param>,...). The fallback defaults(when not changed bydiff.dirstat) arechanges,noncumulative,3.The following parameters are available:

changes

Compute the dirstat numbers by counting the lines that have beenremoved from the source, or added to the destination. This ignoresthe amount of pure code movements within a file. In other words,rearranging lines in a file is not counted as much as other changes.This is the default behavior when no parameter is given.

lines

Compute the dirstat numbers by doing the regular line-based diffanalysis, and summing the removed/added line counts. (For binaryfiles, count 64-byte chunks instead, since binary files have nonatural concept of lines). This is a more expensive--dirstatbehavior than thechanges behavior, but it does count rearrangedlines within a file as much as other changes. The resulting outputis consistent with what you get from the other--*stat options.

files

Compute the dirstat numbers by counting the number of files changed.Each changed file counts equally in the dirstat analysis. This isthe computationally cheapest--dirstat behavior, since it doesnot have to look at the file contents at all.

cumulative

Count changes in a child directory for the parent directory as well.Note that when usingcumulative, the sum of the percentagesreported may exceed 100%. The default (non-cumulative) behavior canbe specified with thenoncumulative parameter.

<limit>

An integer parameter specifies a cut-off percent (3% by default).Directories contributing less than this percentage of the changesare not shown in the output.

Example: The following will count changed files, while ignoringdirectories with less than 10% of the total amount of changed files,and accumulating child directory counts in the parent directories:files,10,cumulative.

diff.statNameWidth

Limit the width of the filename part in--stat output. If set, appliesto all commands generating--stat output exceptformat-patch.

diff.statGraphWidth

Limit the width of the graph part in--stat output. If set, appliesto all commands generating--stat output exceptformat-patch.

diff.context

Generate diffs with<n> lines of context instead of the defaultof 3. This value is overridden by the-U option.

diff.interHunkContext

Show the context between diff hunks, up to the specified numberof lines, thereby fusing the hunks that are close to each other.This value serves as the default for the--inter-hunk-contextcommand line option.

diff.external

If this config variable is set, diff generation is notperformed using the internal diff machinery, but using thegiven command. Can be overridden with theGIT_EXTERNAL_DIFFenvironment variable. The command is called with parametersas described under "git Diffs" ingit(1). Note: ifyou want to use an external diff program only on a subset ofyour files, you might want to usegitattributes(5) instead.

diff.trustExitCode

If this boolean value is set totrue then thediff.external command is expected to return exit code0 if it considers the input files to be equal or 1 if itconsiders them to be different, likediff(1).If it is set tofalse, which is the default, then the commandis expected to return exit code0 regardless of equality.Any other exit code causes Git to report a fatal error.

diff.ignoreSubmodules

Sets the default value of--ignore-submodules. Note that thisaffects onlygitdiff Porcelain, and not lower leveldiffcommands such asgitdiff-files.gitcheckoutandgitswitch also honorthis setting when reporting uncommitted changes. Setting it toall disables the submodule summary normally shown bygitcommitandgitstatus whenstatus.submoduleSummary is set unless it isoverridden by using the--ignore-submodules command-line option.Thegitsubmodule commands are not affected by this setting.By default this is set to untracked so that any untrackedsubmodules are ignored.

diff.mnemonicPrefix

If set,gitdiff uses a prefix pair that is different from thestandarda/ andb/ depending on what is being compared. Whenthis configuration is in effect, reverse diff output also swapsthe order of the prefixes:

gitdiff

compares the (i)ndex and the (w)ork tree;

gitdiffHEAD

compares a (c)ommit and the (w)ork tree;

gitdiff--cached

compares a (c)ommit and the (i)ndex;

gitdiffHEAD:<file1><file2>

compares an (o)bject and a (w)ork tree entity;

gitdiff--no-index<a><b>

compares two non-git things<a> and<b>.

diff.noPrefix

If set,gitdiff does not show any source or destination prefix.

diff.srcPrefix

If set,gitdiff uses this source prefix. Defaults toa/.

diff.dstPrefix

If set,gitdiff uses this destination prefix. Defaults tob/.

diff.relative

If set totrue,gitdiff does not show changes outside of the directoryand show pathnames relative to the current directory.

diff.orderFile

File indicating how to order files within a diff.See the-O option togit-diff(1) for details.Ifdiff.orderFile is a relative pathname, it is treated asrelative to the top of the working tree.

diff.renameLimit

The number of files to consider in the exhaustive portion ofcopy/rename detection; equivalent to thegitdiff option-l. If not set, the default value is currently 1000. Thissetting has no effect if rename detection is turned off.

diff.renames

Whether and how Git detects renames. If set tofalse,rename detection is disabled. If set totrue, basic renamedetection is enabled. If set tocopies orcopy, Git willdetect copies, as well. Defaults totrue. Note that thisaffects onlygitdiff Porcelain likegit-diff(1) andgit-log(1), and not lower level commands such asgit-diff-files(1).

diff.suppressBlankEmpty

A boolean to inhibit the standard behavior of printing a spacebefore each empty output line. Defaults tofalse.

diff.submodule

Specify the format in which differences in submodules areshown. Theshort format just shows the names of the commitsat the beginning and end of the range. Thelog format liststhe commits in the range likegit-submodule(1)summarydoes. Thediff format shows an inline diff of the changedcontents of the submodule. Defaults toshort.

diff.wordRegex

A POSIX Extended Regular Expression used to determine what is a "word"when performing word-by-word difference calculations. Charactersequences that match the regular expression are "words", all othercharacters areignorable whitespace.

diff.<driver>.command

The custom diff driver command. Seegitattributes(5)for details.

diff.<driver>.trustExitCode

If this boolean value is set totrue then thediff.<driver>.command command is expected to return exit code0 if it considers the input files to be equal or 1 if itconsiders them to be different, likediff(1).If it is set tofalse, which is the default, then the commandis expected to return exit code 0 regardless of equality.Any other exit code causes Git to report a fatal error.

diff.<driver>.xfuncname

The regular expression that the diff driver should use torecognize the hunk header. A built-in pattern may also be used.Seegitattributes(5) for details.

diff.<driver>.binary

Set this option totrue to make the diff driver treat files asbinary. Seegitattributes(5) for details.

diff.<driver>.textconv

The command that the diff driver should call to generate thetext-converted version of a file. The result of theconversion is used to generate a human-readable diff. Seegitattributes(5) for details.

diff.<driver>.wordRegex

The regular expression that the diff driver should use tosplit words in a line. Seegitattributes(5) fordetails.

diff.<driver>.cachetextconv

Set this option totrue to make the diff driver cache the textconversion outputs. Seegitattributes(5) for details.

diff.indentHeuristic

Set this option tofalse to disable the default heuristicsthat shift diff hunk boundaries to make patches easier to read.

diff.algorithm

Choose a diff algorithm. The variants are as follows:

default

myers

The basic greedy diff algorithm. Currently, this is the default.

minimal

Spend extra time to make sure the smallest possible diff isproduced.

patience

Use "patience diff" algorithm when generating patches.

histogram

This algorithm extends the patience algorithm to "supportlow-occurrence common elements".

diff.wsErrorHighlight

Highlight whitespace errors in thecontext,old ornewlines of the diff. Multiple values are separated by comma,none resets previous values,default reset the list tonew andall is a shorthand forold,new,context. Thewhitespace errors are colored withcolor.diff.whitespace.The command line option--ws-error-highlight=<kind>overrides this setting.

diff.colorMoved

If set to either a valid<mode> or atrue value, moved linesin a diff are colored differently.For details of valid modes see--color-moved ingit-diff(1).If simply set totrue the default color mode will be used. Whenset tofalse, moved lines are not colored.

diff.colorMovedWS

When moved lines are colored using e.g. thediff.colorMoved setting,this option controls the mode how spaces are treated.For details of valid modes see--color-moved-ws ingit-diff(1).

diff.tool

Controls which diff tool is used bygit-difftool(1).This variable overrides the value configured inmerge.tool.The list below shows the valid built-in values.Any other value is treated as a custom diff tool and requiresthat a corresponding difftool.<tool>.cmd variable is defined.

diff.guitool

Controls which diff tool is used bygit-difftool(1) whenthe -g/--gui flag is specified. This variable overrides the valueconfigured inmerge.guitool. The list below shows the validbuilt-in values. Any other value is treated as a custom diff tooland requires that a corresponding difftool.<guitool>.cmd variableis defined.

araxis

Use Araxis Merge (requires a graphical session)

bc

Use Beyond Compare (requires a graphical session)

bc3

Use Beyond Compare (requires a graphical session)

bc4

Use Beyond Compare (requires a graphical session)

codecompare

Use Code Compare (requires a graphical session)

deltawalker

Use DeltaWalker (requires a graphical session)

diffmerge

Use DiffMerge (requires a graphical session)

diffuse

Use Diffuse (requires a graphical session)

ecmerge

Use ECMerge (requires a graphical session)

emerge

Use Emacs' Emerge

examdiff

Use ExamDiff Pro (requires a graphical session)

guiffy

Use Guiffy’s Diff Tool (requires a graphical session)

gvimdiff

Use gVim (requires a graphical session)

kdiff3

Use KDiff3 (requires a graphical session)

kompare

Use Kompare (requires a graphical session)

meld

Use Meld (requires a graphical session)

nvimdiff

Use Neovim

opendiff

Use FileMerge (requires a graphical session)

p4merge

Use HelixCore P4Merge (requires a graphical session)

smerge

Use Sublime Merge (requires a graphical session)

tkdiff

Use TkDiff (requires a graphical session)

vimdiff

Use Vim

vscode

Use Visual Studio Code (requires a graphical session)

winmerge

Use WinMerge (requires a graphical session)

xxdiff

Use xxdiff (requires a graphical session)

difftool.<tool>.cmd

Specify the command to invoke the specified diff tool.The specified command is evaluated in shell with the followingvariables available:LOCAL is set to the name of the temporaryfile containing the contents of the diff pre-image andREMOTEis set to the name of the temporary file containing the contentsof the diff post-image.

See the--tool=<tool> option ingit-difftool(1) for more details.

difftool.<tool>.path

Override the path for the given tool. This is useful in caseyour tool is not in the PATH.

difftool.trustExitCode

Exit difftool if the invoked diff tool returns a non-zero exit status.

See the--trust-exit-code option ingit-difftool(1) for more details.

difftool.prompt

Prompt before each invocation of the diff tool.

difftool.guiDefault

Settrue to use thediff.guitool by default (equivalent to specifyingthe--gui argument), orauto to selectdiff.guitool ordiff.tooldepending on the presence of aDISPLAY environment variable value. Thedefault isfalse, where the--gui argument must be providedexplicitly for thediff.guitool to be used.

extensions.*

Unless otherwise stated, is an error to specify an extension ifcore.repositoryFormatVersion is not1. Seegitrepository-layout(5).

compatObjectFormat

Specify a compatibility hash algorithm to use. The acceptable valuesaresha1 andsha256. The value specified must be different from thevalue ofextensions.objectFormat. This allows client levelinteroperability between git repositories whose objectFormat matchesthis compatObjectFormat. In particular when fully implemented thepushes and pulls from a repository in whose objectFormat matchescompatObjectFormat. As well as being able to use oids encoded incompatObjectFormat in addition to oids encoded with objectFormat tolocally specify objects.

Note that the functionality enabled by this extension is incomplete and subjectto change. It currently exists only to allow development and testing ofthe underlying feature and is not designed to be enabled by end users.

noop

This extension does not change git’s behavior at all. It is useful onlyfor testing format-1 compatibility.

For historical reasons, this extension is respected regardless of thecore.repositoryFormatVersion setting.

noop-v1

This extension does not change git’s behavior at all. It is useful onlyfor testing format-1 compatibility.

objectFormat

Specify the hash algorithm to use. The acceptable values aresha1 andsha256. If not specified,sha1 is assumed.

Note that this setting should only be set bygit-init(1) orgit-clone(1). Trying to change it after initialization will notwork and will produce hard-to-diagnose issues.

partialClone

When enabled, indicates that the repo was created with a partial clone(or later performed a partial fetch) and that the remote may haveomitted sending certain unwanted objects. Such a remote is called a"promisor remote" and it promises that all such omitted objects canbe fetched from it in the future.

The value of this key is the name of the promisor remote.

For historical reasons, this extension is respected regardless of thecore.repositoryFormatVersion setting.

preciousObjects

If enabled, indicates that objects in the repository MUST NOT be deleted(e.g., bygit-prune orgitrepack-d).

For historical reasons, this extension is respected regardless of thecore.repositoryFormatVersion setting.

refStorage

Specify the ref storage format to use. The acceptable values are:

• files for loose files with packed-refs. This is the default.

• reftable for the reftable format. This format is experimental and itsinternals are subject to change.

Note that this setting should only be set bygit-init(1) orgit-clone(1). Trying to change it after initialization will notwork and will produce hard-to-diagnose issues.

relativeWorktrees

If enabled, indicates at least one worktree has been linked withrelative paths. Automatically set if a worktree has been created orrepaired with either the--relative-paths option or with theworktree.useRelativePaths config set totrue.

worktreeConfig

If enabled, then worktrees will load config settings from the$GIT_DIR/config.worktree file in addition to the$GIT_COMMON_DIR/config file. Note that$GIT_COMMON_DIR and$GIT_DIR are the same for the main working tree, while otherworking trees have$GIT_DIR equal to$GIT_COMMON_DIR/worktrees/<id>/. The settings in theconfig.worktree file will override settings from any otherconfig files.

When enabling this extension, you must be careful to movecertain values from the common config file to the main working tree’sconfig.worktree file, if present:

• core.worktree must be moved from$GIT_COMMON_DIR/config to$GIT_COMMON_DIR/config.worktree.

• Ifcore.bare is true, then it must be moved from$GIT_COMMON_DIR/configto$GIT_COMMON_DIR/config.worktree.

It may also be beneficial to adjust the locations ofcore.sparseCheckoutandcore.sparseCheckoutCone depending on your desire for customizablesparse-checkout settings for each worktree. By default, thegitsparse-checkout builtin enables this extension, assignsthese config values on a per-worktree basis, and uses the$GIT_DIR/info/sparse-checkout file to specify the sparsity for eachworktree independently. Seegit-sparse-checkout(1) for moredetails.

For historical reasons, this extension is respected regardless of thecore.repositoryFormatVersion setting.

fastimport.unpackLimit

If the number of objects imported bygit-fast-import(1)is below this limit, then the objects will be unpacked intoloose object files. However, if the number of imported objectsequals or exceeds this limit, then the pack will be stored as apack. Storing the pack from a fast-import can make the importoperation complete faster, especially on slow filesystems. Ifnot set, the value oftransfer.unpackLimit is used instead.

feature.*

The config settings that start withfeature. modify the defaults ofa group of other config settings. These groups are created by the Gitdeveloper community as recommended defaults and are subject to change.In particular, new config options may be added with different defaults.

feature.experimental

Enable config options that are new to Git, and are being considered forfuture defaults. Config settings included here may be added or removedwith each release, including minor version updates. These settings mayhave unintended interactions since they are so new. Please enable thissetting if you are interested in providing feedback on experimentalfeatures. The new default values are:

• fetch.negotiationAlgorithm=skipping may improve fetch negotiation times byskipping more commits at a time, reducing the number of round trips.

• pack.useBitmapBoundaryTraversal=true may improve bitmap traversal times bywalking fewer objects.

• pack.allowPackReuse=multi may improve the time it takes to create a pack byreusing objects from multiple packs instead of just one.

• pack.usePathWalk may speed up packfile creation and make the packfiles besignificantly smaller in the presence of certain filename collisions with Git’sdefault name-hash.

• init.defaultRefFormat=reftable causes newly initialized repositories to usethe reftable format for storing references. This new format solves issues withcase-insensitive filesystems, compresses better and performs significantlybetter with many use cases. Refer to Documentation/technical/reftable.adoc formore information on this new storage format.

feature.manyFiles

Enable config options that optimize for repos with many files in theworking directory. With many files, commands such asgitstatus andgitcheckout may be slow and these new defaults improve performance:

• index.skipHash=true speeds up index writes by not computing a trailingchecksum. Note that this will cause Git versions earlier than 2.13.0 torefuse to parse the index and Git versions earlier than 2.40.0 will reporta corrupted index duringgitfsck.

• index.version=4 enables path-prefix compression in the index.

• core.untrackedCache=true enables the untracked cache. This setting assumesthat mtime is working on your machine.

fetch.recurseSubmodules

This option controls whethergitfetch (and the underlying fetchingitpull) will recursively fetch into populated submodules.This option can be set either to a boolean value or toon-demand.Setting it to a boolean changes the behavior of fetch and pull torecurse unconditionally into submodules when set to true or to notrecurse at all when set to false. When set toon-demand, fetch andpull will only recurse into a populated submodule when itssuperproject retrieves a commit that updates the submodule’sreference.Defaults toon-demand, or to the value ofsubmodule.recurse if set.

fetch.fsckObjects

If it is set to true, git-fetch-pack will check all fetchedobjects. Seetransfer.fsckObjects for what’schecked. Defaults to false. If not set, the value oftransfer.fsckObjects is used instead.

fetch.fsck.<msg-id>

Acts likefsck.<msg-id>, but is used bygit-fetch-pack(1) instead ofgit-fsck(1). Seethefsck.<msg-id> documentation for details.

fetch.fsck.skipList

Acts likefsck.skipList, but is used bygit-fetch-pack(1) instead ofgit-fsck(1). Seethefsck.skipList documentation for details.

fetch.unpackLimit

If the number of objects fetched over the Git nativetransfer is below thislimit, then the objects will be unpacked into loose objectfiles. However if the number of received objects equals orexceeds this limit then the received pack will be stored asa pack, after adding any missing delta bases. Storing thepack from a push can make the push operation complete faster,especially on slow filesystems. If not set, the value oftransfer.unpackLimit is used instead.

fetch.prune

If true, fetch will automatically behave as if the--pruneoption was given on the command line. See alsoremote.<name>.pruneand the PRUNING section ofgit-fetch(1).

fetch.pruneTags

If true, fetch will automatically behave as if therefs/tags/*:refs/tags/* refspec was provided when pruning,if not set already. This allows for setting both this optionandfetch.prune to maintain a 1=1 mapping to upstreamrefs. See alsoremote.<name>.pruneTags and the PRUNINGsection ofgit-fetch(1).

fetch.all

If true, fetch will attempt to update all available remotes.This behavior can be overridden by passing--no-all or byexplicitly specifying one or more remote(s) to fetch from.Defaults to false.

fetch.output

Control how ref update status is printed. Valid values arefull andcompact. Default value isfull. See theOUTPUT section ingit-fetch(1) for details.

fetch.negotiationAlgorithm

Control how information about the commits in the local repositoryis sent when negotiating the contents of the packfile to be sent bythe server. Set to "consecutive" to use an algorithm that walksover consecutive commits checking each one. Set to "skipping" touse an algorithm that skips commits in an effort to convergefaster, but may result in a larger-than-necessary packfile; or setto "noop" to not send any information at all, which will almostcertainly result in a larger-than-necessary packfile, but will skipthe negotiation step. Set to "default" to override settings madepreviously and use the default behaviour. The default is normally"consecutive", but iffeature.experimental is true, then thedefault is "skipping". Unknown values will causegit fetch toerror out.

See also the--negotiate-only and--negotiation-tip options togit-fetch(1).

fetch.showForcedUpdates

Set to false to enable--no-show-forced-updates ingit-fetch(1) andgit-pull(1) commands.Defaults to true.

fetch.parallel

Specifies the maximal number of fetch operations to be run in parallelat a time (submodules, or remotes when the--multiple option ofgit-fetch(1) is in effect).

A value of 0 will give some reasonable default. If unset, it defaults to 1.

For submodules, this setting can be overridden using thesubmodule.fetchJobsconfig setting.

fetch.writeCommitGraph

Set to true to write a commit-graph after everygitfetch commandthat downloads a pack-file from a remote. Using the--split option,most executions will create a very small commit-graph file on top ofthe existing commit-graph file(s). Occasionally, these files willmerge and the write may take longer. Having an updated commit-graphfile helps performance of many Git commands, includinggitmerge-base,gitpush-f, andgitlog--graph. Defaults to false.

fetch.bundleURI

This value stores a URI for downloading Git object data from a bundleURI before performing an incremental fetch from the origin Git server.This is similar to how the--bundle-uri option behaves ingit-clone(1).gitclone--bundle-uri will set thefetch.bundleURI value if the supplied bundle URI contains a bundlelist that is organized for incremental fetches.

If you modify this value and your repository has afetch.bundleCreationTokenvalue, then remove thatfetch.bundleCreationToken value before fetching fromthe new bundle URI.

fetch.bundleCreationToken

When usingfetch.bundleURI to fetch incrementally from a bundlelist that uses the "creationToken" heuristic, this config valuestores the maximumcreationToken value of the downloaded bundles.This value is used to prevent downloading bundles in the futureif the advertisedcreationToken is not strictly larger than thisvalue.

The creation token values are chosen by the provider serving the specificbundle URI. If you modify the URI atfetch.bundleURI, then be sure toremove the value for thefetch.bundleCreationToken value before fetching.

filter.<driver>.clean

The command which is used to convert the content of a worktreefile to a blob upon checkin. Seegitattributes(5) fordetails.

filter.<driver>.smudge

The command which is used to convert the content of a blobobject to a worktree file upon checkout. Seegitattributes(5) for details.

format.attach

Enable multipart/mixed attachments as the default forformat-patch. The value can also be a double quoted stringwhich will enable attachments as the default and set thevalue as the boundary. See the --attach option ingit-format-patch(1). To countermand an earliervalue, set it to an empty string.

format.from

Provides the default value for the--from option to format-patch.Accepts a boolean value, or a name and email address. If false,format-patch defaults to--no-from, using commit authors directly inthe "From:" field of patch mails. If true, format-patch defaults to--from, using your committer identity in the "From:" field of patchmails and including a "From:" field in the body of the patch mail ifdifferent. If set to a non-boolean value, format-patch uses thatvalue instead of your committer identity. Defaults to false.

format.forceInBodyFrom

Provides the default value for the--[no-]force-in-body-fromoption to format-patch. Defaults to false.

format.numbered

A boolean which can enable or disable sequence numbers in patchsubjects. It defaults to "auto" which enables it only if thereis more than one patch. It can be enabled or disabled for allmessages by setting it to "true" or "false". See --numberedoption ingit-format-patch(1).

format.headers

Additional email headers to include in a patch to be submittedby mail. Seegit-format-patch(1).

format.to

format.cc

Additional recipients to include in a patch to be submittedby mail. See the --to and --cc options ingit-format-patch(1).

format.subjectPrefix

The default for format-patch is to output files with the[PATCH]subject prefix. Use this variable to change that prefix.

format.coverFromDescription

The default mode for format-patch to determine which parts ofthe cover letter will be populated using the branch’sdescription. See the--cover-from-description option ingit-format-patch(1).

format.signature

The default for format-patch is to output a signature containingthe Git version number. Use this variable to change that default.Set this variable to the empty string ("") to suppresssignature generation.

format.signatureFile

Works just like format.signature except the contents of thefile specified by this variable will be used as the signature.

format.suffix

The default for format-patch is to output files with the suffix.patch. Use this variable to change that suffix (make sure toinclude the dot if you want it).

format.encodeEmailHeaders

Encode email headers that have non-ASCII characters with"Q-encoding" (described in RFC 2047) for email transmission.Defaults to true.

format.pretty

The default pretty format for log/show/whatchanged command.Seegit-log(1),git-show(1),git-whatchanged(1).

format.thread

The default threading style forgit format-patch. Can bea boolean value, orshallow ordeep.shallow threadingmakes every mail a reply to the head of the series,where the head is chosen from the cover letter, the--in-reply-to, and the first patch mail, in this order.deep threading makes every mail a reply to the previous one.A true boolean value is the same asshallow, and a falsevalue disables threading.

format.signOff

A boolean value which lets you enable the-s/--signoff option offormat-patch by default.Note: Adding theSigned-off-by trailer to apatch should be a conscious act and means that you certify you havethe rights to submit this work under the same open source license.Please see theSubmittingPatches document for further discussion.

format.coverLetter

A boolean that controls whether to generate a cover-letter whenformat-patch is invoked, but in addition can be set to "auto", togenerate a cover-letter only when there’s more than one patch.Default is false.

format.outputDirectory

Set a custom directory to store the resulting files instead of thecurrent working directory. All directory components will be created.

format.filenameMaxLength

The maximum length of the output filenames generated by theformat-patch command; defaults to 64. Can be overriddenby the--filename-max-length=<n> command line option.

format.useAutoBase

A boolean value which lets you enable the--base=auto option offormat-patch by default. Can also be set to "whenAble" to allowenabling--base=auto if a suitable base is available, but to skipadding base info otherwise without the format dying.

format.notes

Provides the default value for the--notes option toformat-patch. Accepts a boolean value, or a ref which specifieswhere to get notes. If false, format-patch defaults to--no-notes. If true, format-patch defaults to--notes. Ifset to a non-boolean value, format-patch defaults to--notes=<ref>, whereref is the non-boolean value. Defaultsto false.

If one wishes to use the refrefs/notes/true, please use that literalinstead.

This configuration can be specified multiple times in order to allowmultiple notes refs to be included. In that case, it will behavesimilarly to multiple--[no-]notes[=] options passed in. That is, avalue oftrue will show the default notes, a value of<ref> willalso show notes from that notes ref and a value offalse will negateprevious configurations and not show notes.

For example,

[format]        notes = true        notes = foo        notes = false        notes = bar

will only show notes fromrefs/notes/bar.

format.mboxrd

A boolean value which enables the robust "mboxrd" format when--stdout is in use to escape "^>+From " lines.

format.noprefix

If set, do not show any source or destination prefix in patches.This is equivalent to thediff.noprefix option used bygitdiff (but which is not respected byformat-patch). Note thatby setting this, the receiver of any patches you generate willhave to apply them using the-p0 option.

fsck.<msg-id>

During fsck git may find issues with legacy data whichwouldn’t be generated by current versions of git, and whichwouldn’t be sent over the wire iftransfer.fsckObjects wasset. This feature is intended to support working with legacyrepositories containing such data.

Settingfsck.<msg-id> will be picked up bygit-fsck(1), butto accept pushes of such data setreceive.fsck.<msg-id> instead, orto clone or fetch it setfetch.fsck.<msg-id>.

The rest of the documentation discussesfsck.* for brevity, but thesame applies for the correspondingreceive.fsck.* andfetch.fsck.*. variables.

Unlike variables likecolor.ui andcore.editor, thereceive.fsck.<msg-id> andfetch.fsck.<msg-id> variables will notfall back on thefsck.<msg-id> configuration if they aren’t set. Touniformly configure the same fsck settings in different circumstances,all three of them must be set to the same values.

Whenfsck.<msg-id> is set, errors can be switched to warnings andvice versa by configuring thefsck.<msg-id> setting where the<msg-id> is the fsck message ID and the value is one oferror,warn orignore. For convenience, fsck prefixes the error/warningwith the message ID, e.g. "missingEmail: invalid author/committerline - missing email" means that settingfsck.missingEmail=ignorewill hide that issue.

In general, it is better to enumerate existing objects with problemswithfsck.skipList, instead of listing the kind of breakages theseproblematic objects share to be ignored, as doing the latter willallow new instances of the same breakages go unnoticed.

Setting an unknownfsck.<msg-id> value will cause fsck to die, butdoing the same forreceive.fsck.<msg-id> andfetch.fsck.<msg-id>will only cause git to warn.

See theFsckMessages section ofgit-fsck(1) for supportedvalues of<msg-id>.

fsck.skipList

The path to a list of object names (i.e. one unabbreviated SHA-1 perline) that are known to be broken in a non-fatal way and shouldbe ignored. On versions of Git 2.20 and later, comments (#), emptylines, and any leading and trailing whitespace are ignored. Everythingbut a SHA-1 per line will error out on older versions.

This feature is useful when an established project should be accepteddespite early commits containing errors that can be safely ignored,such as invalid committer email addresses. Note: corrupt objectscannot be skipped with this setting.

Likefsck.<msg-id> this variable has correspondingreceive.fsck.skipList andfetch.fsck.skipList variants.

Unlike variables likecolor.ui andcore.editor thereceive.fsck.skipList andfetch.fsck.skipList variables will notfall back on thefsck.skipList configuration if they aren’t set. Touniformly configure the same fsck settings in different circumstances,all three of them must be set to the same values.

Older versions of Git (before 2.20) documented that the object nameslist should be sorted. This was never a requirement; the object namescould appear in any order, but when reading the list we tracked whetherthe list was sorted for the purposes of an internal binary searchimplementation, which could save itself some work with an already sortedlist. Unless you had a humongous list there was no reason to go out ofyour way to pre-sort the list. After Git version 2.20 a hash implementationis used instead, so there’s now no reason to pre-sort the list.

fsmonitor.allowRemote

By default, the fsmonitor daemon refuses to work with network-mountedrepositories. Settingfsmonitor.allowRemote totrue overrides thisbehavior. Only respected whencore.fsmonitor is set totrue.

fsmonitor.socketDir

This Mac OS-specific option, if set, specifies the directory inwhich to create the Unix domain socket used for communicationbetween the fsmonitor daemon and various Git commands. The directory mustreside on a native Mac OS filesystem. Only respected whencore.fsmonitoris set totrue.

gc.aggressiveDepth

The depth parameter used in the delta compressionalgorithm used bygit gc --aggressive. This defaultsto 50, which is the default for the--depth option when--aggressive isn’t in use.

See the documentation for the--depth option ingit-repack(1) for more details.

gc.aggressiveWindow

The window size parameter used in the delta compressionalgorithm used bygit gc --aggressive. This defaultsto 250, which is a much more aggressive window size thanthe default--window of 10.

See the documentation for the--window option ingit-repack(1) for more details.

gc.auto

When there are approximately more than this many looseobjects in the repository,gitgc--auto will pack them.Some Porcelain commands use this command to perform alight-weight garbage collection from time to time. Thedefault value is 6700.

Setting this to 0 disables not only automatic packing based on thenumber of loose objects, but also any other heuristicgitgc--auto willotherwise use to determine if there’s work to do, such asgc.autoPackLimit.

gc.autoPackLimit

When there are more than this many packs that are notmarked with*.keep file in the repository,gitgc--auto consolidates them into one larger pack. Thedefault value is 50. Setting this to 0 disables it.Settinggc.auto to 0 will also disable this.

See thegc.bigPackThreshold configuration variable below. When inuse, it’ll affect how the auto pack limit works.

gc.autoDetach

Makegitgc--auto return immediately and run in the backgroundif the system supports it. Default is true. This config variable actsas a fallback in casemaintenance.autoDetach is not set.

gc.bigPackThreshold

If non-zero, all non-cruft packs larger than this limit are keptwhengitgc is run. This is very similar to--keep-largest-pack except that all non-cruft packs that meetthe threshold are kept, not just the largest pack. Defaults tozero. Common unit suffixes ofk,m, org are supported.

Note that if the number of kept packs is more than gc.autoPackLimit,this configuration variable is ignored, all packs except the base packwill be repacked. After this the number of packs should go belowgc.autoPackLimit and gc.bigPackThreshold should be respected again.

If the amount of memory estimated forgitrepack to run smoothly isnot available andgc.bigPackThreshold is not set, the largest packwill also be excluded (this is the equivalent of runninggitgc with--keep-largest-pack).

gc.writeCommitGraph

If true, then gc will rewrite the commit-graph file whengit-gc(1) is run. When usinggitgc--autothe commit-graph will be updated if housekeeping isrequired. Default is true. Seegit-commit-graph(1)for details.

gc.logExpiry

If the file gc.log exists, thengitgc--auto will printits content and exit with status zero instead of runningunless that file is more thangc.logExpiry old. Default is"1.day". Seegc.pruneExpire for more ways to specify itsvalue.

gc.packRefs

Runninggitpack-refs in a repository renders itunclonable by Git versions prior to 1.5.1.2 over dumbtransports such as HTTP. This variable determines whethergit gc runsgitpack-refs. This can be set tonotbareto enable it within all non-bare repos or it can be set to aboolean value. The default istrue.

gc.cruftPacks

Store unreachable objects in a cruft pack (seegit-repack(1)) instead of as loose objects. The defaultistrue.

gc.maxCruftSize

Limit the size of new cruft packs when repacking. Whenspecified in addition to--max-cruft-size, the command lineoption takes priority. See the--max-cruft-size option ofgit-repack(1).

gc.pruneExpire

Whengit gc is run, it will callprune --expire 2.weeks.ago(andrepack --cruft --cruft-expiration 2.weeks.ago if usingcruft packs viagc.cruftPacks or--cruft). Override thegrace period with this config variable. The value "now" may beused to disable this grace period and always prune unreachableobjects immediately, or "never" may be used to suppress pruning.This feature helps prevent corruption whengit gc runsconcurrently with another process writing to the repository; seethe "NOTES" section ofgit-gc(1).

gc.worktreePruneExpire

Whengit gc is run, it callsgit worktree prune --expire 3.months.ago.This config variable can be used to set a different graceperiod. The value "now" may be used to disable the graceperiod and prune$GIT_DIR/worktrees immediately, or "never"may be used to suppress pruning.

gc.reflogExpire

gc.<pattern>.reflogExpire

git reflog expire removes reflog entries older thanthis time; defaults to 90 days. The value "now" expires allentries immediately, and "never" suppresses expirationaltogether. With "<pattern>" (e.g."refs/stash") in the middle the setting applies only tothe refs that match the <pattern>.

gc.reflogExpireUnreachable

gc.<pattern>.reflogExpireUnreachable

git reflog expire removes reflog entries older thanthis time and are not reachable from the current tip;defaults to 30 days. The value "now" expires all entriesimmediately, and "never" suppresses expiration altogether.With "<pattern>" (e.g. "refs/stash")in the middle, the setting applies only to the refs thatmatch the <pattern>.

These types of entries are generally created as a result of usinggitcommit--amend orgitrebase and are the commits prior to the amendor rebase occurring. Since these changes are not part of the currentproject most users will want to expire them sooner, which is why thedefault is more aggressive thangc.reflogExpire.

gc.recentObjectsHook

When considering whether or not to remove an object (either whengenerating a cruft pack or storing unreachable objects asloose), use the shell to execute the specified command(s).Interpret their output as object IDs which Git will consider as"recent", regardless of their age. By treating their mtimes as"now", any objects (and their descendants) mentioned in theoutput will be kept regardless of their true age.

Output must contain exactly one hex object ID per line, and nothingelse. Objects which cannot be found in the repository are ignored.Multiple hooks are supported, but all must exit successfully, else theoperation (either generating a cruft pack or unpacking unreachableobjects) will be halted.

gc.repackFilter

When repacking, use the specified filter to move certainobjects into a separate packfile. See the--filter=<filter-spec> option ofgit-repack(1).

gc.repackFilterTo

When repacking and using a filter, seegc.repackFilter, thespecified location will be used to create the packfilecontaining the filtered out objects.WARNING: Thespecified location should be accessible, using for example theGit alternates mechanism, otherwise the repo could beconsidered corrupt by Git as it might not be able to access theobjects in that packfile. See the--filter-to=<dir> optionofgit-repack(1) and theobjects/info/alternatessection ofgitrepository-layout(5).

gc.rerereResolved

Records of conflicted merge you resolved earlier arekept for this many days whengit rerere gc is run.You can also use more human-readable "1.month.ago", etc.The default is 60 days. Seegit-rerere(1).

gc.rerereUnresolved

Records of conflicted merge you have not resolved arekept for this many days whengit rerere gc is run.You can also use more human-readable "1.month.ago", etc.The default is 15 days. Seegit-rerere(1).

gitcvs.commitMsgAnnotation

Append this string to each commit message. Set to empty stringto disable this feature. Defaults to "via git-CVS emulator".

gitcvs.enabled

Whether the CVS server interface is enabled for this repository.Seegit-cvsserver(1).

gitcvs.logFile

Path to a log file where the CVS server interface well…​ logsvarious stuff. Seegit-cvsserver(1).

gitcvs.usecrlfattr

If true, the server will look up the end-of-line conversionattributes for files to determine the-k modes to use. Ifthe attributes force Git to treat a file as text,the-k mode will be left blank so CVS clients willtreat it as text. If they suppress text conversion, the filewill be set with-kb mode, which suppresses any newline mungingthe client might otherwise do. If the attributes do not allowthe file type to be determined, thengitcvs.allBinary isused. Seegitattributes(5).

gitcvs.allBinary

This is used ifgitcvs.usecrlfattr does not resolvethe correct-kb mode to use. If true, allunresolved files are sent to the client inmode-kb. This causes the client to treat themas binary files, which suppresses any newline munging itotherwise might do. Alternatively, if it is set to "guess",then the contents of the file are examined to decide ifit is binary, similar tocore.autocrlf.

gitcvs.dbName

Database used by git-cvsserver to cache revision informationderived from the Git repository. The exact meaning depends on theused database driver, for SQLite (which is the default driver) thisis a filename. Supports variable substitution (seegit-cvsserver(1) for details). May not contain semicolons (;).Default:%Ggitcvs.%m.sqlite

gitcvs.dbDriver

Used Perl DBI driver. You can specify any available driverfor this here, but it might not work. git-cvsserver is testedwithDBD::SQLite, reported to work withDBD::Pg, andreportednot to work withDBD::mysql. Experimental feature.May not contain double colons (:). Default:SQLite.Seegit-cvsserver(1).

gitcvs.dbUser

gitcvs.dbPass

Database user and password. Only useful if settinggitcvs.dbDriver,since SQLite has no concept of database users and/or passwords.gitcvs.dbUser supports variable substitution (seegit-cvsserver(1) for details).

gitcvs.dbTableNamePrefix

Database table name prefix. Prepended to the names of anydatabase tables used, allowing a single database to be usedfor several repositories. Supports variable substitution (seegit-cvsserver(1) for details). Any non-alphabeticcharacters will be replaced with underscores.

All gitcvs variables except forgitcvs.usecrlfattr andgitcvs.allBinary can also be specified asgitcvs.<access_method>.<varname> (whereaccess_methodis one of "ext" and "pserver") to make them apply only for the givenaccess method.

gitweb.category

gitweb.description

gitweb.owner

gitweb.url

Seegitweb(1) for description.

gitweb.avatar

gitweb.blame

gitweb.grep

gitweb.highlight

gitweb.patches

gitweb.pickaxe

gitweb.remote_heads

gitweb.showSizes

gitweb.snapshot

Seegitweb.conf(5) for description.

gpg.program

Pathname of the program to use instead of "gpg" whenmaking or verifying a PGP signature. The program must support thesame command-line interface as GPG, namely, to verify a detachedsignature, "gpg--verify$signature- <$file" is run, and theprogram is expected to signal a good signature by exiting withcode 0. To generate an ASCII-armored detached signature, thestandard input of "gpg-bsau$key" is fed with the contents to besigned, and the program is expected to send the result to itsstandard output.

gpg.format

Specifies which key format to use when signing with--gpg-sign.Default is "openpgp". Other possible values are "x509", "ssh".

Seegitformat-signature(5) for the signature format, which differsbased on the selectedgpg.format.

gpg.<format>.program

Use this to customize the program used for the signing format youchose. (seegpg.program andgpg.format)gpg.program can stillbe used as a legacy synonym forgpg.openpgp.program. The defaultvalue forgpg.x509.program is "gpgsm" andgpg.ssh.program is "ssh-keygen".

gpg.minTrustLevel

Specifies a minimum trust level for signature verification. Ifthis option is unset, then signature verification for mergeoperations requires a key with at leastmarginal trust. Otheroperations that perform signature verification require a keywith at leastundefined trust. Setting this option overridesthe required trust-level for all operations. Supported values,in increasing order of significance:

• undefined

• never

• marginal

• fully

• ultimate

gpg.ssh.defaultKeyCommand

This command will be run when user.signingkey is not set and a sshsignature is requested. On successful exit a valid ssh public keyprefixed withkey:: is expected in the first line of its output.This allows for a script doing a dynamic lookup of the correct publickey when it is impractical to statically configureuser.signingKey.For example when keys or SSH Certificates are rotated frequently orselection of the right key depends on external factors unknown to git.

gpg.ssh.allowedSignersFile

A file containing ssh public keys which you are willing to trust.The file consists of one or more lines of principals followed by an sshpublic key.e.g.:user1@example.com,user2@example.comssh-rsaAAAAX1...See ssh-keygen(1) "ALLOWED SIGNERS" for details.The principal is only used to identify the key and is available whenverifying a signature.

SSH has no concept of trust levels like gpg does. To be able to differentiatebetween valid signatures and trusted signatures the trust level of a signatureverification is set tofully when the public key is present in the allowedSignersFile.Otherwise the trust level isundefined and git verify-commit/tag will fail.

This file can be set to a location outside of the repository and every developermaintains their own trust store. A central repository server could generate thisfile automatically from ssh keys with push access to verify the code against.In a corporate setting this file is probably generated at a global locationfrom automation that already handles developer ssh keys.

A repository that only allows signed commits can store the filein the repository itself using a path relative to the top-level of the working tree.This way only committers with an already valid key can add or change keys in the keyring.

Since OpensSSH 8.8 this file allows specifying a key lifetime using valid-after &valid-before options. Git will mark signatures as valid if the signing key wasvalid at the time of the signature’s creation. This allows users to change asigning key without invalidating all previously made signatures.

Using a SSH CA key with the cert-authority option(see ssh-keygen(1) "CERTIFICATES") is also valid.

gpg.ssh.revocationFile

Either a SSH KRL or a list of revoked public keys (without the principal prefix).See ssh-keygen(1) for details.If a public key is found in this file then it will always be treatedas having trust level "never" and signatures will show as invalid.

grep.lineNumber

If set to true, enable-n option by default.

grep.column

If set to true, enable the--column option by default.

grep.patternType

Set the default matching behavior. Using a value ofbasic,extended,fixed, orperl will enable the--basic-regexp,--extended-regexp,--fixed-strings, or--perl-regexp option accordingly, while thevaluedefault will use thegrep.extendedRegexp option to choosebetweenbasic andextended.

grep.extendedRegexp

If set to true, enable--extended-regexp option by default. Thisoption is ignored when thegrep.patternType option is set to a valueother thandefault.

grep.threads

Number of grep worker threads to use. If unset (or set to 0), Git willuse as many threads as the number of logical cores available.

grep.fullName

If set to true, enable--full-name option by default.

grep.fallbackToNoIndex

If set to true, fall back togitgrep--no-index ifgitgrepis executed outside of a git repository. Defaults to false.

gui.commitMsgWidth

Defines how wide the commit message window is in thegit-gui(1). "75" is the default.

gui.diffContext

Specifies how many context lines should be used in calls to diffmade by thegit-gui(1). The default is "5".

gui.displayUntracked

Determines ifgit-gui(1) shows untracked filesin the file list. The default is "true".

gui.encoding

Specifies the default character encoding to use for displaying offile contents ingit-gui(1) andgitk(1).It can be overridden by setting theencoding attributefor relevant files (seegitattributes(5)).If this option is not set, the tools default to thelocale encoding.

gui.matchTrackingBranch

Determines if new branches created withgit-gui(1) shoulddefault to tracking remote branches with matching names ornot. Default: "false".

gui.newBranchTemplate

Is used as a suggested name when creating new branches using thegit-gui(1).

gui.pruneDuringFetch

"true" ifgit-gui(1) should prune remote-tracking branches whenperforming a fetch. The default value is "false".

gui.trustmtime

Determines ifgit-gui(1) should trust the file modificationtimestamp or not. By default the timestamps are not trusted.

gui.spellingDictionary

Specifies the dictionary used for spell checking commit messages inthegit-gui(1). When set to "none" spell checking is turnedoff.

gui.fastCopyBlame

If true,git gui blame uses-C instead of-C-C for originallocation detection. It makes blame significantly faster on hugerepositories at the expense of less thorough copy detection.

gui.copyBlameThreshold

Specifies the threshold to use ingit gui blame original locationdetection, measured in alphanumeric characters. See thegit-blame(1) manual for more information on copy detection.

gui.blamehistoryctx

Specifies the radius of history context in days to show ingitk(1) for the selected commit, when theShowHistoryContext menu item is invoked fromgit gui blame. If thisvariable is set to zero, the whole history is shown.

guitool.<name>.cmd

Specifies the shell command line to execute when the corresponding itemof thegit-gui(1)Tools menu is invoked. This option ismandatory for every tool. The command is executed from the root ofthe working directory, and in the environment it receives the name ofthe tool asGIT_GUITOOL, the name of the currently selected file asFILENAME, and the name of the current branch asCUR_BRANCH (ifthe head is detached,CUR_BRANCH is empty).

guitool.<name>.needsFile

Run the tool only if a diff is selected in the GUI. It guaranteesthatFILENAME is not empty.

guitool.<name>.noConsole

Run the command silently, without creating a window to display itsoutput.

guitool.<name>.noRescan

Don’t rescan the working directory for changes after the toolfinishes execution.

guitool.<name>.confirm

Show a confirmation dialog before actually running the tool.

guitool.<name>.argPrompt

Request a string argument from the user, and pass it to the toolthrough theARGS environment variable. Since requesting anargument implies confirmation, theconfirm option has no effectif this is enabled. If the option is set totrue,yes, or1,the dialog uses a built-in generic prompt; otherwise the exactvalue of the variable is used.

guitool.<name>.revPrompt

Request a single valid revision from the user, and set theREVISION environment variable. In other aspects this optionis similar toargPrompt, and can be used together with it.

guitool.<name>.revUnmerged

Show only unmerged branches in therevPrompt subdialog.This is useful for tools similar to merge or rebase, but notfor things like checkout or reset.

guitool.<name>.title

Specifies the title to use for the prompt dialog. The defaultis the tool name.

guitool.<name>.prompt

Specifies the general prompt string to display at the top ofthe dialog, before subsections forargPrompt andrevPrompt.The default value includes the actual command.

help.browser

Specify the browser that will be used to display help in theweb format. Seegit-help(1).

help.format

Override the default help format used bygit-help(1).Valuesman,info,web andhtml are supported.man isthe default.web andhtml are the same.

help.autoCorrect

If git detects typos and can identify exactly one valid command similarto the error, git will try to suggest the correct command or evenrun the suggestion automatically. Possible config values are:

• 0, "false", "off", "no", "show": show the suggested command (default).

• 1, "true", "on", "yes", "immediate": run the suggested commandimmediately.

• positive number > 1: run the suggested command after specifieddeciseconds (0.1 sec).

• "never": don’t run or show any suggested command.

• "prompt": show the suggestion and prompt for confirmation to runthe command.

help.htmlPath

Specify the path where the HTML documentation resides. File system pathsand URLs are supported. HTML pages will be prefixed with this path whenhelp is displayed in theweb format. This defaults to the documentationpath of your Git installation.

http.proxy

Override the HTTP proxy, normally configured using thehttp_proxy,https_proxy, andall_proxy environment variables (seecurl(1)). Inaddition to the syntax understood by curl, it is possible to specify aproxy string with a user name but no password, in which case git willattempt to acquire one in the same way it does for other credentials. Seegitcredentials(7) for more information. The syntax thus is[protocol://][user[:password]@]proxyhost[:port][/path]. This can beoverridden on a per-remote basis; see remote.<name>.proxy

Any proxy, however configured, must be completely transparent and must notmodify, transform, or buffer the request or response in any way. Proxies whichare not completely transparent are known to cause various forms of breakagewith Git.

http.proxyAuthMethod

Set the method with which to authenticate against the HTTP proxy. Thisonly takes effect if the configured proxy string contains a user name part(i.e. is of the formuser@host oruser@host:port). This can beoverridden on a per-remote basis; seeremote.<name>.proxyAuthMethod.Both can be overridden by theGIT_HTTP_PROXY_AUTHMETHOD environmentvariable. Possible values are:

• anyauth - Automatically pick a suitable authentication method. It isassumed that the proxy answers an unauthenticated request with a 407status code and one or more Proxy-authenticate headers with supportedauthentication methods. This is the default.

• basic - HTTP Basic authentication

• digest - HTTP Digest authentication; this prevents the password from beingtransmitted to the proxy in clear text

• negotiate - GSS-Negotiate authentication (compare the --negotiate optionofcurl(1))

• ntlm - NTLM authentication (compare the --ntlm option ofcurl(1))

http.proxySSLCert

The pathname of a file that stores a client certificate to use to authenticatewith an HTTPS proxy. Can be overridden by theGIT_PROXY_SSL_CERT environmentvariable.

http.proxySSLKey

The pathname of a file that stores a private key to use to authenticate withan HTTPS proxy. Can be overridden by theGIT_PROXY_SSL_KEY environmentvariable.

http.proxySSLCertPasswordProtected

Enable Git’s password prompt for the proxy SSL certificate. Otherwise OpenSSLwill prompt the user, possibly many times, if the certificate or private keyis encrypted. Can be overridden by theGIT_PROXY_SSL_CERT_PASSWORD_PROTECTEDenvironment variable.

http.proxySSLCAInfo

Pathname to the file containing the certificate bundle that should be used toverify the proxy with when using an HTTPS proxy. Can be overridden by theGIT_PROXY_SSL_CAINFO environment variable.

http.emptyAuth

Attempt authentication without seeking a username or password. Thiscan be used to attempt GSS-Negotiate authentication without specifyinga username in the URL, as libcurl normally requires a username forauthentication.

http.proactiveAuth

Attempt authentication without first making an unauthenticated attempt andreceiving a 401 response. This can be used to ensure that all requests areauthenticated. Ifhttp.emptyAuth is set to true, this value has no effect.

If the credential helper used specifies an authentication scheme (i.e., via theauthtype field), that value will be used; if a username and password isprovided without a scheme, then Basic authentication is used. The value of theoption determines the scheme requested from the helper. Possible values are:

• basic - Request Basic authentication from the helper.

• auto - Allow the helper to pick an appropriate scheme.

• none - Disable proactive authentication.

Note that TLS should always be used with this configuration, since otherwise itis easy to accidentally expose plaintext credentials if Basic authenticationis selected.

http.delegation

Control GSSAPI credential delegation. The delegation is disabledby default in libcurl since version 7.21.7. Set parameter to tellthe server what it is allowed to delegate when it comes to usercredentials. Used with GSS/kerberos. Possible values are:

• none - Don’t allow any delegation.

• policy - Delegates if and only if the OK-AS-DELEGATE flag is set in theKerberos service ticket, which is a matter of realm policy.

• always - Unconditionally allow the server to delegate.

http.extraHeader

Pass an additional HTTP header when communicating with a server. Ifmore than one such entry exists, all of them are added as extraheaders. To allow overriding the settings inherited from the systemconfig, an empty value will reset the extra headers to the empty list.

http.cookieFile

The pathname of a file containing previously stored cookie lines,which should be usedin the Git http session, if they match the server. The file formatof the file to read cookies from should be plain HTTP headers orthe Netscape/Mozilla cookie file format (seecurl(1)).Set it to an empty string, to accept only new cookies fromthe server and send them back in successive requests within sameconnection.NOTE that the file specified with http.cookieFile is used only asinput unless http.saveCookies is set.

http.saveCookies

If set, store cookies received during requests to the file specified byhttp.cookieFile. Has no effect if http.cookieFile is unset, or set toan empty string.

http.version

Use the specified HTTP protocol version when communicating with a server.If you want to force the default. The available and default version dependon libcurl. Currently the possible values ofthis option are:

• HTTP/2

• HTTP/1.1

http.curloptResolve

Hostname resolution information that will be used first bylibcurl when sending HTTP requests. This information shouldbe in one of the following formats:

• [+]HOST:PORT:ADDRESS[,ADDRESS]

• -HOST:PORT

The first format redirects all requests to the givenHOST:PORTto the providedADDRESS(s). The second format clears allprevious config values for thatHOST:PORT combination. Toallow easy overriding of all the settings inherited from thesystem config, an empty value will reset all resolutioninformation to the empty list.

http.sslVersion

The SSL version to use when negotiating an SSL connection, if youwant to force the default. The available and default versiondepend on whether libcurl was built against NSS or OpenSSL and theparticular configuration of the crypto library in use. Internallythis sets theCURLOPT_SSL_VERSION option; see the libcurldocumentation for more details on the format of this option andfor the ssl version supported. Currently the possible values ofthis option are:

• sslv2

• sslv3

• tlsv1

• tlsv1.0

• tlsv1.1

• tlsv1.2

• tlsv1.3

Can be overridden by theGIT_SSL_VERSION environment variable.To force git to use libcurl’s default ssl version and ignore anyexplicit http.sslversion option, setGIT_SSL_VERSION to theempty string.

http.sslCipherList

A list of SSL ciphers to use when negotiating an SSL connection.The available ciphers depend on whether libcurl was built againstNSS or OpenSSL and the particular configuration of the cryptolibrary in use. Internally this sets theCURLOPT_SSL_CIPHER_LISToption; see the libcurl documentation for more details on the formatof this list.

Can be overridden by theGIT_SSL_CIPHER_LIST environment variable.To force git to use libcurl’s default cipher list and ignore anyexplicit http.sslCipherList option, setGIT_SSL_CIPHER_LIST to theempty string.

http.sslVerify

Whether to verify the SSL certificate when fetching or pushingover HTTPS. Defaults to true. Can be overridden by theGIT_SSL_NO_VERIFY environment variable.

http.sslCert

File containing the SSL certificate when fetching or pushingover HTTPS. Can be overridden by theGIT_SSL_CERT environmentvariable.

http.sslKey

File containing the SSL private key when fetching or pushingover HTTPS. Can be overridden by theGIT_SSL_KEY environmentvariable.

http.sslCertPasswordProtected

Enable Git’s password prompt for the SSL certificate. OtherwiseOpenSSL will prompt the user, possibly many times, if thecertificate or private key is encrypted. Can be overridden by theGIT_SSL_CERT_PASSWORD_PROTECTED environment variable.

http.sslCAInfo

File containing the certificates to verify the peer with whenfetching or pushing over HTTPS. Can be overridden by theGIT_SSL_CAINFO environment variable.

http.sslCAPath

Path containing files with the CA certificates to verify the peerwith when fetching or pushing over HTTPS. Can be overriddenby theGIT_SSL_CAPATH environment variable.

http.sslBackend

Name of the SSL backend to use (e.g. "openssl" or "schannel").This option is ignored if cURL lacks support for choosing the SSLbackend at runtime.

http.sslCertType

Type of client certificate used when fetching or pushing over HTTPS."PEM", "DER" are supported when using openssl or gnutls backends. "P12"is supported on "openssl", "schannel", "securetransport", and gnutls 8.11+.See also libcurlCURLOPT_SSLCERTTYPE. Can be overridden by theGIT_SSL_CERT_TYPE environment variable.

http.sslKeyType

Type of client private key used when fetching or pushing over HTTPS. (e.g."PEM", "DER", or "ENG"). Only applicable when using "openssl" backend. "DER"is not supported with openssl. Particularly useful when set to "ENG" forauthenticating with PKCS#11 tokens, with a PKCS#11 URL in sslCert option.See also libcurlCURLOPT_SSLKEYTYPE. Can be overridden by theGIT_SSL_KEY_TYPE environment variable.

http.schannelCheckRevoke

Used to enforce or disable certificate revocation checks in cURLwhen http.sslBackend is set to "schannel". Defaults totrue ifunset. Only necessary to disable this if Git consistently errorsand the message is about checking the revocation status of acertificate. This option is ignored if cURL lacks support forsetting the relevant SSL option at runtime.

http.schannelUseSSLCAInfo

As of cURL v7.60.0, the Secure Channel backend can use thecertificate bundle provided viahttp.sslCAInfo, but that wouldoverride the Windows Certificate Store. Since this is not desirableby default, Git will tell cURL not to use that bundle by defaultwhen theschannel backend was configured viahttp.sslBackend,unlesshttp.schannelUseSSLCAInfo overrides this behavior.

http.pinnedPubkey

Public key of the https service. It may either be the filename ofa PEM or DER encoded public key file or a string starting withsha256// followed by the base64 encoded sha256 hash of thepublic key. See also libcurlCURLOPT_PINNEDPUBLICKEY. git willexit with an error if this option is set but not supported bycURL.

http.sslTry

Attempt to use AUTH SSL/TLS and encrypted data transferswhen connecting via regular FTP protocol. This might be neededif the FTP server requires it for security reasons or you wishto connect securely whenever remote FTP server supports it.Default is false since it might trigger certificate verificationerrors on misconfigured servers.

http.maxRequests

How many HTTP requests to launch in parallel. Can be overriddenby theGIT_HTTP_MAX_REQUESTS environment variable. Default is 5.

http.minSessions

The number of curl sessions (counted across slots) to be kept acrossrequests. They will not be ended with curl_easy_cleanup() untilhttp_cleanup() is invoked. If USE_CURL_MULTI is not defined, thisvalue will be capped at 1. Defaults to 1.

http.postBuffer

Maximum size in bytes of the buffer used by smart HTTPtransports when POSTing data to the remote system.For requests larger than this buffer size, HTTP/1.1 andTransfer-Encoding: chunked is used to avoid creating amassive pack file locally. Default is 1 MiB, which issufficient for most requests.

Note that raising this limit is only effective for disabling chunkedtransfer encoding and therefore should be used only where the remoteserver or a proxy only supports HTTP/1.0 or is noncompliant with theHTTP standard. Raising this is not, in general, an effective solutionfor most push problems, but can increase memory consumptionsignificantly since the entire buffer is allocated even for smallpushes.

http.lowSpeedLimit

http.lowSpeedTime

If the HTTP transfer speed, in bytes per second, is less thanhttp.lowSpeedLimit for longer thanhttp.lowSpeedTime seconds,the transfer is aborted.Can be overridden by theGIT_HTTP_LOW_SPEED_LIMIT andGIT_HTTP_LOW_SPEED_TIME environment variables.

http.keepAliveIdle

Specifies how long in seconds to wait on an idle connectionbefore sending TCP keepalive probes (if supported by the OS). Ifunset, curl’s default value is used. Can be overridden by theGIT_HTTP_KEEPALIVE_IDLE environment variable.

http.keepAliveInterval

Specifies how long in seconds to wait between TCP keepaliveprobes (if supported by the OS). If unset, curl’s default valueis used. Can be overridden by theGIT_HTTP_KEEPALIVE_INTERVALenvironment variable.

http.keepAliveCount

Specifies how many TCP keepalive probes to send before giving upand terminating the connection (if supported by the OS). Ifunset, curl’s default value is used. Can be overridden by theGIT_HTTP_KEEPALIVE_COUNT environment variable.

http.noEPSV

A boolean which disables using of EPSV ftp command by curl.This can be helpful with some "poor" ftp servers which don’tsupport EPSV mode. Can be overridden by theGIT_CURL_FTP_NO_EPSVenvironment variable. Default is false (curl will use EPSV).

http.userAgent

The HTTP USER_AGENT string presented to an HTTP server. The defaultvalue represents the version of the Git client such as git/1.7.1.This option allows you to override this value to a more common valuesuch as Mozilla/4.0. This may be necessary, for instance, ifconnecting through a firewall that restricts HTTP connections to a setof common USER_AGENT strings (but not including those like git/1.7.1).Can be overridden by theGIT_HTTP_USER_AGENT environment variable.

http.followRedirects

Whether git should follow HTTP redirects. If set totrue, gitwill transparently follow any redirect issued by a server itencounters. If set tofalse, git will treat all redirects aserrors. If set toinitial, git will follow redirects only forthe initial request to a remote, but not for subsequentfollow-up HTTP requests. Since git uses the redirected URL asthe base for the follow-up requests, this is generallysufficient. The default isinitial.

http.<url>.*

Any of the http.* options above can be applied selectively to some URLs.For a config key to match a URL, each element of the config key iscompared to that of the URL, in the following order:

1. Scheme (e.g.,https inhttps://example.com/). This fieldmust match exactly between the config key and the URL.

2. Host/domain name (e.g.,example.com inhttps://example.com/).This field must match between the config key and the URL. It ispossible to specify a* as part of the host name to match all subdomainsat this level.https://*.example.com/ for example would matchhttps://foo.example.com/, but nothttps://foo.bar.example.com/.

3. Port number (e.g.,8080 inhttp://example.com:8080/).This field must match exactly between the config key and the URL.Omitted port numbers are automatically converted to the correctdefault for the scheme before matching.

4. Path (e.g.,repo.git inhttps://example.com/repo.git). Thepath field of the config key must match the path field of the URLeither exactly or as a prefix of slash-delimited path elements. This meansa config key with pathfoo/ matches URL pathfoo/bar. A prefix can onlymatch on a slash (/) boundary. Longer matches take precedence (so a configkey with pathfoo/bar is a better match to URL pathfoo/bar than a configkey with just pathfoo/).

5. User name (e.g.,user inhttps://user@example.com/repo.git). Ifthe config key has a user name it must match the user name in theURL exactly. If the config key does not have a user name, thatconfig key will match a URL with any user name (including none),but at a lower precedence than a config key with a user name.

The list above is ordered by decreasing precedence; a URL that matchesa config key’s path is preferred to one that matches its user name. For example,if the URL ishttps://user@example.com/foo/bar a config key match ofhttps://example.com/foo will be preferred over a config key match ofhttps://user@example.com.

All URLs are normalized before attempting any matching (the password part,if embedded in the URL, is always ignored for matching purposes) so thatequivalent URLs that are simply spelled differently will match properly.Environment variable settings always override any matches. The URLs that arematched against are those given directly to Git commands. This means any URLsvisited as a result of a redirection do not participate in matching.

i18n.commitEncoding

Character encoding the commit messages are stored in; Git itselfdoes not care per se, but this information is necessary e.g. whenimporting commits from emails or in the gitk graphical historybrowser (and possibly in other places in the future or in otherporcelains). See e.g.git-mailinfo(1). Defaults toutf-8.

i18n.logOutputEncoding

Character encoding the commit messages are converted to whenrunninggit log and friends.

imap.folder

The folder to drop the mails into, which is typically the Draftsfolder. For example:INBOX.Drafts,INBOX/Drafts or[Gmail]/Drafts. The IMAP folder to interact with MUST be specified;the value of this configuration variable is used as the fallbackdefault value when the--folder option is not given.

imap.tunnel

Command used to set up a tunnel to the IMAP server through whichcommands will be piped instead of using a direct network connectionto the server. Required when imap.host is not set.

imap.host

A URL identifying the server. Use animap:// prefix for non-secureconnections and animaps:// prefix for secure connections.Ignored when imap.tunnel is set, but required otherwise.

imap.user

The username to use when logging in to the server.

imap.pass

The password to use when logging in to the server.

imap.port

An integer port number to connect to on the server.Defaults to 143 for imap:// hosts and 993 for imaps:// hosts.Ignored when imap.tunnel is set.

imap.sslverify

A boolean to enable/disable verification of the server certificateused by the SSL/TLS connection. Default istrue. Ignored whenimap.tunnel is set.

imap.preformattedHTML

A boolean to enable/disable the use of html encoding when sendinga patch. An html encoded patch will be bracketed with <pre>and have a content type of text/html. Ironically, enabling thisoption causes Thunderbird to send the patch as a plain/text,format=fixed email. Default isfalse.

imap.authMethod

Specify the authentication method for authenticating with the IMAP server.If Git was built with the NO_CURL option, or if your curl version is olderthan 7.34.0, or if you’re running git-imap-send with the--no-curloption, the only supported methods arePLAIN,CRAM-MD5,OAUTHBEARERandXOAUTH2. If this is not set thengitimap-send uses the basic IMAPplaintextLOGIN command.

include.path

includeIf.<condition>.path

Special variables to include other configuration files. Seethe "CONFIGURATION FILE" section in the maingit-config(1) documentation,specifically the "Includes" and "Conditional Includes" subsections.

index.recordEndOfIndexEntries

Specifies whether the index file should include an "End Of IndexEntry" section. This reduces index load time on multiprocessormachines but produces a message "ignoring EOIE extension" whenreading the index using Git versions before 2.20. Defaults totrue if index.threads has been explicitly enabled,falseotherwise.

index.recordOffsetTable

Specifies whether the index file should include an "Index EntryOffset Table" section. This reduces index load time onmultiprocessor machines but produces a message "ignoring IEOTextension" when reading the index using Git versions before 2.20.Defaults totrue if index.threads has been explicitly enabled,false otherwise.

index.sparse

When enabled, write the index using sparse-directory entries. Thishas no effect unlesscore.sparseCheckout andcore.sparseCheckoutCone are both enabled. Defaults tofalse.

index.threads

Specifies the number of threads to spawn when loading the index.This is meant to reduce index load time on multiprocessor machines.Specifying 0 ortrue will cause Git to auto-detect the number ofCPUs and set the number of threads accordingly. Specifying 1 orfalse will disable multithreading. Defaults totrue.

index.version

Specify the version with which new index files should beinitialized. This does not affect existing repositories.Iffeature.manyFiles is enabled, then the default is 4.

index.skipHash

When enabled, do not compute the trailing hash for the index file.This accelerates Git commands that manipulate the index, such asgitadd,gitcommit, orgitstatus. Instead of storing thechecksum, write a trailing set of bytes with value zero, indicatingthat the computation was skipped.

If you enableindex.skipHash, then Git clients older than 2.13.0 willrefuse to parse the index and Git clients older than 2.40.0 will report anerror duringgitfsck.

init.templateDir

Specify the directory from which templates will be copied. (See the "TEMPLATE DIRECTORY" section ofgit-init(1).)

init.defaultBranch

Allows overriding the default branch name e.g. when initializinga new repository.

init.defaultObjectFormat

Allows overriding the default object format for new repositories. See--object-format= ingit-init(1). Both the command line optionand theGIT_DEFAULT_HASH environment variable take precedence overthis config.

init.defaultRefFormat

Allows overriding the default ref storage format for new repositories.See--ref-format= ingit-init(1). Both the command lineoption and theGIT_DEFAULT_REF_FORMAT environment variable takeprecedence over this config.

instaweb.browser

Specify the program that will be used to browse your workingrepository in gitweb. Seegit-instaweb(1).

instaweb.httpd

The HTTP daemon command-line to start gitweb on your workingrepository. Seegit-instaweb(1).

instaweb.local

If true the web server started bygit-instaweb(1) willbe bound to the local IP (127.0.0.1).

instaweb.modulePath

The default module path forgit-instaweb(1) to useinstead of /usr/lib/apache2/modules. Only used if httpdis Apache.

instaweb.port

The port number to bind the gitweb httpd to. Seegit-instaweb(1).

interactive.singleKey

When set to true, allow the user to provide one-letter inputwith a single key (i.e., without hitting the Enter key) ininteractive commands. This is currently used by the--patchmode ofgit-add(1),git-checkout(1),git-restore(1),git-commit(1),git-reset(1), andgit-stash(1).

interactive.diffFilter

When an interactive command (such asgitadd--patch) showsa colorized diff, git will pipe the diff through the shellcommand defined by this configuration variable. The command maymark up the diff further for human consumption, provided that itretains a one-to-one correspondence with the lines in theoriginal diff. Defaults to disabled (no filtering).

log.abbrevCommit

Iftrue, makegit-log(1),git-show(1), andgit-whatchanged(1)assume--abbrev-commit. You mayoverride this option with--no-abbrev-commit.

log.date

Set the default date-time mode for thelog command.Setting a value for log.date is similar to usinggitlog's--date option. Seegit-log(1) for details.

If the format is set to "auto:foo" and the pager is in use, format"foo" will be used for the date format. Otherwise, "default" willbe used.

log.decorate

Print out the ref names of any commits that are shown by the logcommand. Possible values are:

short

the ref name prefixesrefs/heads/,refs/tags/ andrefs/remotes/ are not printed.

full

the full ref name (including prefix) are printed.

auto

if the output is going to a terminal,the ref names are shown as ifshort were given, otherwise no refnames are shown.

This is the same as the--decorate option of thegitlog.

log.initialDecorationSet

By default,gitlog only shows decorations for certain known refnamespaces. Ifall is specified, then show all refs asdecorations.

log.excludeDecoration

Exclude the specified patterns from the log decorations. This issimilar to the--decorate-refs-exclude command-line option, butthe config option can be overridden by the--decorate-refsoption.

log.diffMerges

Set diff format to be used when--diff-merges=on isspecified, see--diff-merges ingit-log(1) fordetails. Defaults toseparate.

log.follow

Iftrue,gitlog will act as if the--follow option was used whena single <path> is given. This has the same limitations as--follow,i.e. it cannot be used to follow multiple files and does not work wellon non-linear history.

log.graphColors

A list of colors, separated by commas, that can be used to drawhistory lines ingitlog--graph.

log.showRoot

If true, the initial commit will be shown as a big creation event.This is equivalent to a diff against an empty tree.Tools likegit-log(1) orgit-whatchanged(1), whichnormally hide the root commit will now show it. True by default.

log.showSignature

If true, makesgit-log(1),git-show(1), andgit-whatchanged(1) assume--show-signature.

log.mailmap

If true, makesgit-log(1),git-show(1), andgit-whatchanged(1) assume--use-mailmap, otherwiseassume--no-use-mailmap. True by default.

lsrefs.unborn

May be "advertise" (the default), "allow", or "ignore". If "advertise",the server will respond to the client sending "unborn" (as described ingitprotocol-v2(5)) and will advertise support for this feature during theprotocol v2 capability advertisement. "allow" is the same as"advertise" except that the server will not advertise support for thisfeature; this is useful for load-balanced servers that cannot beupdated atomically (for example), since the administrator couldconfigure "allow", then after a delay, configure "advertise".

mailinfo.scissors

If true, makesgit-mailinfo(1) (and thereforegit-am(1)) act by default as if the --scissors optionwas provided on the command-line. When active, this featureremoves everything from the message body before a scissorsline (i.e. consisting mainly of ">8", "8<" and "-").

mailmap.file

The location of an augmenting mailmap file. The defaultmailmap, located in the root of the repository, is loadedfirst, then the mailmap file pointed to by this variable.The location of the mailmap file may be in a repositorysubdirectory, or somewhere outside of the repository itself.Seegit-shortlog(1) andgit-blame(1).

mailmap.blob

Likemailmap.file, but consider the value as a reference to ablob in the repository. If bothmailmap.file andmailmap.blob are given, both are parsed, with entries frommailmap.file taking precedence. In a bare repository, thisdefaults toHEAD:.mailmap. In a non-bare repository, itdefaults to empty.

maintenance.auto

This boolean config option controls whether some commands rungitmaintenancerun--auto after doing their normal work. Defaultsto true.

maintenance.autoDetach

Many Git commands trigger automatic maintenance after they havewritten data into the repository. This boolean config optioncontrols whether this automatic maintenance shall happen in theforeground or whether the maintenance process shall detach andcontinue to run in the background.

If unset, the value ofgc.autoDetach is used as a fallback. Defaultsto true if both are unset, meaning that the maintenance process willdetach.

maintenance.strategy

This string config option provides a way to specify one of a fewrecommended strategies for repository maintenance. This affectswhich tasks are run duringgitmaintenancerun, provided no--task=<task> arguments are provided. This setting impacts manualmaintenance, auto-maintenance as well as scheduled maintenance. Thetasks that run may be different depending on the maintenance type.

The maintenance strategy can be further tweaked by settingmaintenance.<task>.enabled andmaintenance.<task>.schedule. If set, thesevalues are used instead of the defaults provided bymaintenance.strategy.

The possible strategies are:

• none: This strategy implies no tasks are run at all. This is the defaultstrategy for scheduled maintenance.

• gc: This strategy runs thegc task. This is the default strategy formanual maintenance.

• geometric: This strategy performs geometric repacking of packfiles andkeeps auxiliary data structures up-to-date. The strategy expires data in thereflog and removes worktrees that cannot be located anymore. When thegeometric repacking strategy would decide to do an all-into-one repack, thenthe strategy generates a cruft pack for all unreachable objects. Objects thatare already part of a cruft pack will be expired.

  This repacking strategy is a full replacement for thegc strategy and isrecommended for large repositories.

• incremental: This setting optimizes for performing small maintenanceactivities that do not delete any data. This does not schedule thegctask, but runs theprefetch andcommit-graph tasks hourly, theloose-objects andincremental-repack tasks daily, and thepack-refstask weekly. Manual repository maintenance uses thegc task.

maintenance.<task>.enabled

This boolean config option controls whether the maintenance taskwith name<task> is run when no--task option is specified togitmaintenancerun. These config values are ignored if a--task option exists. By default, onlymaintenance.gc.enabledis true.

maintenance.<task>.schedule

This config option controls whether or not the given<task> runsduring agitmaintenancerun--schedule=<frequency> command. Thevalue must be one of "hourly", "daily", or "weekly".

maintenance.commit-graph.auto

This integer config option controls how often thecommit-graph taskshould be run as part ofgitmaintenancerun--auto. If zero, thenthecommit-graph task will not run with the--auto option. Anegative value will force the task to run every time. Otherwise, apositive value implies the command should run when the number ofreachable commits that are not in the commit-graph file is at leastthe value ofmaintenance.commit-graph.auto. The default value is100.

maintenance.loose-objects.auto

This integer config option controls how often theloose-objects taskshould be run as part ofgitmaintenancerun--auto. If zero, thentheloose-objects task will not run with the--auto option. Anegative value will force the task to run every time. Otherwise, apositive value implies the command should run when the number ofloose objects is at least the value ofmaintenance.loose-objects.auto.The default value is 100.

maintenance.loose-objects.batchSize

This integer config option controls the maximum number of loose objectswritten into a packfile during theloose-objects task. The default isfifty thousand. Use value0 to indicate no limit.

maintenance.incremental-repack.auto

This integer config option controls how often theincremental-repacktask should be run as part ofgitmaintenancerun--auto. If zero,then theincremental-repack task will not run with the--autooption. A negative value will force the task to run every time.Otherwise, a positive value implies the command should run when thenumber of pack-files not in the multi-pack-index is at least the valueofmaintenance.incremental-repack.auto. The default value is 10.

maintenance.geometric-repack.auto

This integer config option controls how often thegeometric-repacktask should be run as part ofgitmaintenancerun--auto. If zero,then thegeometric-repack task will not run with the--autooption. A negative value will force the task to run every time.Otherwise, a positive value implies the command should run either whenthere are packfiles that need to be merged together to retain thegeometric progression, or when there are at least this many looseobjects that would be written into a new packfile. The default value is100.

maintenance.geometric-repack.splitFactor

This integer config option controls the factor used for the geometricsequence. See the--geometric= option ingit-repack(1) formore details. Defaults to2.

maintenance.reflog-expire.auto

This integer config option controls how often thereflog-expire taskshould be run as part ofgitmaintenancerun--auto. If zero, thenthereflog-expire task will not run with the--auto option. Anegative value will force the task to run every time. Otherwise, apositive value implies the command should run when the number ofexpired reflog entries in the "HEAD" reflog is at least the value ofmaintenance.loose-objects.auto. The default value is 100.

maintenance.rerere-gc.auto

This integer config option controls how often thererere-gc taskshould be run as part ofgitmaintenancerun--auto. If zero, thenthererere-gc task will not run with the--auto option. A negativevalue will force the task to run every time. Otherwise, any positivevalue implies the command will run when the "rr-cache" directory existsand has at least one entry, regardless of whether it is stale or not.This heuristic may be refined in the future. The default value is 1.

maintenance.worktree-prune.auto

This integer config option controls how often theworktree-prune taskshould be run as part ofgitmaintenancerun--auto. If zero, thentheworktree-prune task will not run with the--auto option. Anegative value will force the task to run every time. Otherwise, apositive value implies the command should run when the number ofprunable worktrees exceeds the value. The default value is 1.

man.viewer

Specify the programs that may be used to display help in theman format. Seegit-help(1).

man.<tool>.cmd

Specify the command to invoke the specified man viewer. Thespecified command is evaluated in shell with the man pagepassed as an argument. (Seegit-help(1).)

man.<tool>.path

Override the path for the given tool that may be used todisplay help in theman format. Seegit-help(1).

merge.conflictStyle

Specify the style in which conflicted hunks are written out toworking tree files upon merge. The default is "merge", whichshows a <<<<<<< conflict marker, changes made by one side,a======= marker, changes made by the other side, and thena >>>>>>> marker. An alternate style, "diff3", adds a |||||||marker and the original text before the======= marker. The"merge" style tends to produce smaller conflict regions than diff3,both because of the exclusion of the original text, and becausewhen a subset of lines match on the two sides, they are just pulledout of the conflict region. Another alternate style, "zdiff3", issimilar to diff3 but removes matching lines on the two sides fromthe conflict region when those matching lines appear near eitherthe beginning or end of a conflict region.

merge.defaultToUpstream

If merge is called without any commit argument, merge the upstreambranches configured for the current branch by using their lastobserved values stored in their remote-tracking branches.The values of thebranch.<currentbranch>.merge that name thebranches at the remote named bybranch.<current-branch>.remoteare consulted, and then they are mapped viaremote.<remote>.fetchto their corresponding remote-tracking branches, and the tips ofthese tracking branches are merged. Defaults to true.

merge.ff

By default, Git does not create an extra merge commit when merginga commit that is a descendant of the current commit. Instead, thetip of the current branch is fast-forwarded. When set tofalse,this variable tells Git to create an extra merge commit in sucha case (equivalent to giving the--no-ff option from the commandline). When set toonly, only such fast-forward merges areallowed (equivalent to giving the--ff-only option from thecommand line).

merge.verifySignatures

If true, this is equivalent to the--verify-signatures commandline option. Seegit-merge(1) for details.

merge.branchdesc

In addition to branch names, populate the log message withthe branch description text associated with them. Defaultsto false.

merge.log

In addition to branch names, populate the log message with atmost the specified number of one-line descriptions from theactual commits that are being merged. Defaults to false, andtrue is a synonym for 20.

merge.suppressDest

By adding a glob that matches the names of integrationbranches to this multi-valued configuration variable, thedefault merge message computed for merges into theseintegration branches will omit "into<branch-name>" fromits title.

An element with an empty value can be used to clear the listof globs accumulated from previous configuration entries.When there is nomerge.suppressDest variable defined, thedefault value ofmaster is used for backward compatibility.

merge.renameLimit

The number of files to consider in the exhaustive portion ofrename detection during a merge. If not specified, defaultsto the value ofdiff.renameLimit. If neithermerge.renameLimit nordiff.renameLimit are specified,currently defaults to 7000. This setting has no effect ifrename detection is turned off.

merge.renames

Whether Git detects renames. If set tofalse, rename detectionis disabled. If set totrue, basic rename detection is enabled.Defaults to the value of diff.renames.

merge.directoryRenames

Whether Git detects directory renames, affecting what happens atmerge time to new files added to a directory on one side ofhistory when that directory was renamed on the other side ofhistory. Possible values are:

false

Directory rename detection is disabled, meaning that such new files will beleft behind in the old directory.

true

Directory rename detection is enabled, meaning that such new files will bemoved into the new directory.

conflict

A conflict will be reported for such paths.

Ifmerge.renames isfalse,merge.directoryRenames is ignored and treatedasfalse. Defaults toconflict.

merge.renormalize

Tell Git that canonical representation of files in therepository has changed over time (e.g. earlier commits recordtext files withCRLF line endings, but recent ones useLF lineendings). In such a repository, for each file where athree-way content merge is needed, Git can convert the datarecorded in commits to a canonical form before performing amerge to reduce unnecessary conflicts. For more information,see section "Merging branches with differing checkin/checkoutattributes" ingitattributes(5).

merge.stat

What, if anything, to print betweenORIG_HEAD and the merge resultat the end of the merge. Possible values are:

false

Show nothing.

true

Showgitdiff--diffstat--summaryORIG_HEAD.

compact

Showgitdiff--compact-summaryORIG_HEAD.

but any unrecognised value (e.g., a value added by a future version ofGit) is taken astrue instead of triggering an error. Defaults totrue.

merge.autoStash

When set totrue, automatically create a temporary stash entrybefore the operation begins, and apply it after the operationends. This means that you can run merge on a dirty worktree.However, use with care: the final stash application after asuccessful merge might result in non-trivial conflicts.This option can be overridden by the--no-autostash and--autostash options ofgit-merge(1).Defaults tofalse.

merge.tool

Controls which merge tool is used bygit-mergetool(1).The list below shows the valid built-in values.Any other value is treated as a custom merge tool and requiresthat a correspondingmergetool.<tool>.cmd variable is defined.

merge.guitool

Controls which merge tool is used bygit-mergetool(1) when the-g/--gui flag is specified. The list below shows the valid built-in values.Any other value is treated as a custom merge tool and requires that acorrespondingmergetool.<guitool>.cmd variable is defined.

araxis

Use Araxis Merge (requires a graphical session)

bc

Use Beyond Compare (requires a graphical session)

bc3

Use Beyond Compare (requires a graphical session)

bc4

Use Beyond Compare (requires a graphical session)

codecompare

Use Code Compare (requires a graphical session)

deltawalker

Use DeltaWalker (requires a graphical session)

diffmerge

Use DiffMerge (requires a graphical session)

diffuse

Use Diffuse (requires a graphical session)

ecmerge

Use ECMerge (requires a graphical session)

emerge

Use Emacs' Emerge

examdiff

Use ExamDiff Pro (requires a graphical session)

guiffy

Use Guiffy’s Diff Tool (requires a graphical session)

gvimdiff

Use gVim (requires a graphical session) with a custom layout (seegithelpmergetool'sBACKENDSPECIFICHINTS section)

gvimdiff1

Use gVim (requires a graphical session) with a 2 panes layout (LOCAL and REMOTE)

gvimdiff2

Use gVim (requires a graphical session) with a 3 panes layout (LOCAL, MERGED and REMOTE)

gvimdiff3

Use gVim (requires a graphical session) where only the MERGED file is shown

kdiff3

Use KDiff3 (requires a graphical session)

meld

Use Meld (requires a graphical session) with optionalautomerge (seegithelpmergetool'sCONFIGURATION section)

nvimdiff

Use Neovim with a custom layout (seegithelpmergetool'sBACKENDSPECIFICHINTS section)

nvimdiff1

Use Neovim with a 2 panes layout (LOCAL and REMOTE)

nvimdiff2

Use Neovim with a 3 panes layout (LOCAL, MERGED and REMOTE)

nvimdiff3

Use Neovim where only the MERGED file is shown

opendiff

Use FileMerge (requires a graphical session)

p4merge

Use HelixCore P4Merge (requires a graphical session)

smerge

Use Sublime Merge (requires a graphical session)

tkdiff

Use TkDiff (requires a graphical session)

tortoisemerge

Use TortoiseMerge (requires a graphical session)

vimdiff

Use Vim with a custom layout (seegithelpmergetool'sBACKENDSPECIFICHINTS section)

vimdiff1

Use Vim with a 2 panes layout (LOCAL and REMOTE)

vimdiff2

Use Vim with a 3 panes layout (LOCAL, MERGED and REMOTE)

vimdiff3

Use Vim where only the MERGED file is shown

vscode

Use Visual Studio Code (requires a graphical session)

winmerge

Use WinMerge (requires a graphical session)

xxdiff

Use xxdiff (requires a graphical session)

merge.verbosity

Controls the amount of output shown by the recursive mergestrategy. Level 0 outputs nothing except a final errormessage if conflicts were detected. Level 1 outputs onlyconflicts, 2 outputs conflicts and file changes. Level 5 andabove outputs debugging information. The default is level 2.Can be overridden by theGIT_MERGE_VERBOSITY environment variable.

merge.<driver>.name

Defines a human-readable name for a custom low-levelmerge driver. Seegitattributes(5) for details.

merge.<driver>.driver

Defines the command that implements a custom low-levelmerge driver. Seegitattributes(5) for details.

merge.<driver>.recursive

Names a low-level merge driver to be used whenperforming an internal merge between common ancestors.Seegitattributes(5) for details.

mergetool.<tool>.path

Override the path for the given tool. This is useful in caseyour tool is not in the$PATH.

mergetool.<tool>.cmd

Specify the command to invoke the specified merge tool. Thespecified command is evaluated in shell with the followingvariables available:BASE is the name of a temporary filecontaining the common base of the files to be merged, if available;LOCAL is the name of a temporary file containing the contents ofthe file on the current branch;REMOTE is the name of a temporaryfile containing the contents of the file from the branch beingmerged;MERGED contains the name of the file to which the mergetool should write the results of a successful merge.

mergetool.<tool>.hideResolved

Allows the user to override the globalmergetool.hideResolved valuefor a specific tool. Seemergetool.hideResolved for the fulldescription.

mergetool.<tool>.trustExitCode

For a custom merge command, specify whether the exit code ofthe merge command can be used to determine whether the merge wassuccessful. If this is not set to true then the merge target filetimestamp is checked, and the merge is assumed to have been successfulif the file has been updated; otherwise, the user is prompted toindicate the success of the merge.

mergetool.meld.hasOutput

Older versions ofmeld do not support the--output option.Git will attempt to detect whethermeld supports--outputby inspecting the output ofmeld--help. Configuringmergetool.meld.hasOutput will make Git skip these checks anduse the configured value instead. Settingmergetool.meld.hasOutputtotrue tells Git to unconditionally use the--output option,andfalse avoids using--output.

mergetool.meld.useAutoMerge

When the--auto-merge is given, meld will merge all non-conflictingparts automatically, highlight the conflicting parts, and wait foruser decision. Settingmergetool.meld.useAutoMerge totrue tellsGit to unconditionally use the--auto-merge option withmeld.Setting this value toauto makes git detect whether--auto-mergeis supported and will only use--auto-merge when available. Avalue offalse avoids using--auto-merge altogether, and is thedefault value.

mergetool.<variant>.layout

Configure the split window layout for vimdiff’s<variant>, which is any ofvimdiff,nvimdiff,gvimdiff.Upon launchinggitmergetool with--tool=<variant> (or without--toolifmerge.tool is configured as<variant>), Git will consultmergetool.<variant>.layout to determine the tool’s layout. If thevariant-specific configuration is not available,vimdiff ' s is used asfallback. If that too is not available, a default layout with 4 windowswill be used. To configure the layout, see theBACKEND SPECIFIC HINTSsection ingit-mergetool(1).

mergetool.hideResolved

During a merge, Git will automatically resolve as many conflicts aspossible and write the$MERGED file containing conflict markers aroundany conflicts that it cannot resolve;$LOCAL and$REMOTE normallyare the versions of the file from before Git’s conflictresolution. This flag causes$LOCAL and$REMOTE to be overwritten sothat only the unresolved conflicts are presented to the merge tool. Canbe configured per-tool via themergetool.<tool>.hideResolvedconfiguration variable. Defaults tofalse.

mergetool.keepBackup

After performing a merge, the original file with conflict markerscan be saved as a file with a .orig extension. If this variableis set tofalse then this file is not preserved. Defaults totrue (i.e. keep the backup files).

mergetool.keepTemporaries

When invoking a custom merge tool, Git uses a set of temporaryfiles to pass to the tool. If the tool returns an error and thisvariable is set totrue, then these temporary files will bepreserved; otherwise, they will be removed after the tool hasexited. Defaults tofalse.

mergetool.writeToTemp

Git writes temporaryBASE,LOCAL, andREMOTE versions ofconflicting files in the worktree by default. Git will attemptto use a temporary directory for these files when settrue.Defaults tofalse.

mergetool.prompt

Prompt before each invocation of the merge resolution program.

mergetool.guiDefault

Settrue to use themerge.guitool by default (equivalent tospecifying the--gui argument), orauto to selectmerge.guitoolormerge.tool depending on the presence of aDISPLAY environmentvariable value. The default isfalse, where the--gui argumentmust be provided explicitly for themerge.guitool to be used.

notes.mergeStrategy

Which merge strategy to choose by default when resolving notesconflicts. Must be one ofmanual,ours,theirs,union, orcat_sort_uniq. Defaults tomanual. See the "NOTES MERGE STRATEGIES"section ofgit-notes(1) for more information on each strategy.

This setting can be overridden by passing the--strategy option togit-notes(1).

notes.<name>.mergeStrategy

Which merge strategy to choose when doing a notes merge intorefs/notes/<name>. This overrides the more generalnotes.mergeStrategy. See the "NOTES MERGE STRATEGIES" section ingit-notes(1) for more information on the available strategies.

notes.displayRef

Which ref (or refs, if a glob or specified more than once), inaddition to the default set bycore.notesRef orGIT_NOTES_REF, to read notes from when showing commitmessages with thegitlog family of commands.

This setting can be overridden with theGIT_NOTES_DISPLAY_REFenvironment variable, which must be a colon separated list of refs orglobs.

A warning will be issued for refs that do not exist,but a glob that does not match any refs is silently ignored.

This setting can be disabled by the--no-notes option to thegit-log(1)family of commands, or by the--notes=<ref> option accepted bythose commands.

The effective value ofcore.notesRef (possibly overridden byGIT_NOTES_REF) is also implicitly added to the list of refs to bedisplayed.

notes.rewrite.<command>

When rewriting commits with<command> (currentlyamend orrebase), if this variable isfalse, git will not copynotes from the original to the rewritten commit. Defaults totrue. See alsonotes.rewriteRef below.

This setting can be overridden with theGIT_NOTES_REWRITE_REFenvironment variable, which must be a colon separated list of refs orglobs.

notes.rewriteMode

When copying notes during a rewrite (see thenotes.rewrite.<command> option), determines what to do ifthe target commit already has a note. Must be one ofoverwrite,concatenate,cat_sort_uniq, orignore.Defaults toconcatenate.

This setting can be overridden with theGIT_NOTES_REWRITE_MODEenvironment variable.

notes.rewriteRef

When copying notes during a rewrite, specifies the (fullyqualified) ref whose notes should be copied. May be a glob,in which case notes in all matching refs will be copied. Youmay also specify this configuration several times.

Does not have a default value; you must configure this variable toenable note rewriting. Set it torefs/notes/commits to enablerewriting for the default commit notes.

Can be overridden with theGIT_NOTES_REWRITE_REF environment variable.Seenotes.rewrite.<command> above for a further description of its format.

pack.window

The size of the window used bygit-pack-objects(1) when nowindow size is given on the command line. Defaults to 10.

pack.depth

The maximum delta depth used bygit-pack-objects(1) when nomaximum depth is given on the command line. Defaults to 50.Maximum value is 4095.

pack.windowMemory

The maximum size of memory that is consumed by each threadingit-pack-objects(1) for pack window memory whenno limit is given on the command line. The value can besuffixed with "k", "m", or "g". When left unconfigured (orset explicitly to 0), there will be no limit.

pack.compression

An integer -1..9, indicating the compression level for objectsin a pack file. -1 is the zlib default. 0 means nocompression, and 1..9 are various speed/size tradeoffs, 9 beingslowest. If not set, defaults to core.compression. If that isnot set, defaults to -1, the zlib default, which is "a defaultcompromise between speed and compression (currently equivalentto level 6)."

Note that changing the compression level will not automatically recompressall existing objects. You can force recompression by passing the -F optiontogit-repack(1).

pack.allowPackReuse

When true or "single", and when reachability bitmaps areenabled, pack-objects will try to send parts of the bitmappedpackfile verbatim. When "multi", and when a multi-packreachability bitmap is available, pack-objects will try to sendparts of all packs in the MIDX.

If only a single pack bitmap is available, andpack.allowPackReuseis set to "multi", reuse parts of just the bitmapped packfile. Thiscan reduce memory and CPU usage to serve fetches, but might result insending a slightly larger pack. Defaults to true.

pack.island

An extended regular expression configuring a set of deltaislands. See "DELTA ISLANDS" ingit-pack-objects(1)for details.

pack.islandCore

Specify an island name which gets to have its objects bepacked first. This creates a kind of pseudo-pack at the frontof one pack, so that the objects from the specified island arehopefully faster to copy into any pack that should be servedto a user requesting these objects. In practice this meansthat the island specified should likely correspond to what isthe most commonly cloned in the repo. See also "DELTA ISLANDS"ingit-pack-objects(1).

pack.deltaCacheSize

The maximum memory in bytes used for caching deltas ingit-pack-objects(1) before writing them out to a pack.This cache is used to speed up the writing object phase by nothaving to recompute the final delta result once the best matchfor all objects is found. Repacking large repositories on machineswhich are tight with memory might be badly impacted by this though,especially if this cache pushes the system into swapping.A value of 0 means no limit. The smallest size of 1 byte may beused to virtually disable this cache. Defaults to 256 MiB.

pack.deltaCacheLimit

The maximum size of a delta, that is cached ingit-pack-objects(1). This cache is used to speed up thewriting object phase by not having to recompute the final deltaresult once the best match for all objects is found.Defaults to 1000. Maximum value is 65535.

pack.threads

Specifies the number of threads to spawn when searching for bestdelta matches. This requires thatgit-pack-objects(1)be compiled with pthreads otherwise this option is ignored with awarning. This is meant to reduce packing time on multiprocessormachines. The required amount of memory for the delta search windowis however multiplied by the number of threads.Specifying 0 will cause Git to auto-detect the number of CPUsand set the number of threads accordingly.

pack.indexVersion

Specify the default pack index version. Valid values are 1 forlegacy pack index used by Git versions prior to 1.5.2, and 2 forthe new pack index with capabilities for packs larger than 4 GBas well as proper protection against the repacking of corruptedpacks. Version 2 is the default. Note that version 2 is enforcedand this config option is ignored whenever the corresponding pack islarger than 2 GB.

If you have an old Git that does not understand the version 2*.idx file,cloning or fetching over a non-native protocol (e.g. "http")that will copy both*.pack file and corresponding*.idx file from theother side may give you a repository that cannot be accessed with yourolder version of Git. If the*.pack file is smaller than 2 GB, however,you can usegit-index-pack(1) on the *.pack file to regeneratethe*.idx file.

pack.packSizeLimit

The maximum size of a pack. This setting only affectspacking to a file when repacking, i.e. the git:// protocolis unaffected. It can be overridden by the--max-pack-sizeoption ofgit-repack(1). Reaching this limit resultsin the creation of multiple packfiles.

Note that this option is rarely useful, and may result in a larger totalon-disk size (because Git will not store deltas between packs) andworse runtime performance (object lookup within multiple packs isslower than a single pack, and optimizations like reachability bitmapscannot cope with multiple packs).

If you need to actively run Git using smaller packfiles (e.g., because yourfilesystem does not support large files), this option may help. But ifyour goal is to transmit a packfile over a medium that supports limitedsizes (e.g., removable media that cannot store the whole repository),you are likely better off creating a single large packfile and splittingit using a generic multi-volume archive tool (e.g., Unixsplit).

The minimum size allowed is limited to 1 MiB. The default is unlimited.Common unit suffixes ofk,m, org are supported.

pack.useBitmaps

When true, git will use pack bitmaps (if available) when packingto stdout (e.g., during the server side of a fetch). Defaults totrue. You should not generally need to turn this off unlessyou are debugging pack bitmaps.

pack.useBitmapBoundaryTraversal

When true, Git will use an experimental algorithm for computingreachability queries with bitmaps. Instead of building upcomplete bitmaps for all of the negated tips and then OR-ingthem together, consider negated tips with existing bitmaps asadditive (i.e. OR-ing them into the result if they exist,ignoring them otherwise), and build up a bitmap at the boundaryinstead.

When using this algorithm, Git may include too many objects as a resultof not opening up trees belonging to certain UNINTERESTING commits. Thisinexactness matches the non-bitmap traversal algorithm.

In many cases, this can provide a speed-up over the exact algorithm,particularly when there is poor bitmap coverage of the negated side ofthe query.

pack.useSparse

When true, git will default to using the--sparse option ingit pack-objects when the--revs option is present. Thisalgorithm only walks trees that appear in paths that introduce newobjects. This can have significant performance benefits whencomputing a pack to send a small change. However, it is possiblethat extra objects are added to the pack-file if the includedcommits contain certain types of direct renames. Default istrue.

pack.usePathWalk

Enable the--path-walk option by default forgitpack-objectsprocesses. Seegit-pack-objects(1) for full details.

pack.preferBitmapTips

When selecting which commits will receive bitmaps, prefer acommit at the tip of any reference that is a suffix of any valueof this configuration over any other commits in the "selectionwindow".

Note that setting this configuration torefs/foo does not mean thatthe commits at the tips ofrefs/foo/bar andrefs/foo/baz willnecessarily be selected. This is because commits are selected forbitmaps from within a series of windows of variable length.

If a commit at the tip of any reference which is a suffix of any valueof this configuration is seen in a window, it is immediately givenpreference over any other commit in that window.

pack.writeBitmaps (deprecated)

This is a deprecated synonym forrepack.writeBitmaps.

pack.writeBitmapHashCache

When true, git will include a "hash cache" section in the bitmapindex (if one is written). This cache can be used to feed git’sdelta heuristics, potentially leading to better deltas betweenbitmapped and non-bitmapped objects (e.g., when serving a fetchbetween an older, bitmapped pack and objects that have beenpushed since the last gc). The downside is that it consumes 4bytes per object of disk space. Defaults to true.

When writing a multi-pack reachability bitmap, no new namehashes arecomputed; instead, any namehashes stored in an existing bitmap arepermuted into their appropriate location when writing a new bitmap.

pack.writeBitmapLookupTable

When true, Git will include a "lookup table" section in thebitmap index (if one is written). This table is used to deferloading individual bitmaps as late as possible. This can bebeneficial in repositories that have relatively large bitmapindexes. Defaults to false.

pack.readReverseIndex

When true, git will read any .rev file(s) that may be available(see:gitformat-pack(5)). When false, the reverse indexwill be generated from scratch and stored in memory. Defaults totrue.

pack.writeReverseIndex

When true, git will write a corresponding .rev file (see:gitformat-pack(5))for each new packfile that it writes in all places except forgit-fast-import(1) and in the bulk checkin mechanism.Defaults to true.

pager.<cmd>

If the value is boolean, turns on or off pagination of theoutput of a particular Git subcommand when writing to a tty.Otherwise, turns on pagination for the subcommand using thepager specified by the value ofpager.<cmd>. If--paginateor--no-pager is specified on the command line, it takesprecedence over this option. To disable pagination for allcommands, setcore.pager orGIT_PAGER tocat.

pretty.<name>

Alias for a --pretty= format string, as specified ingit-log(1). Any aliases defined here can be used justas the built-in pretty formats could. For example,runninggitconfigpretty.changelog "format:*%H%s"would cause the invocationgitlog--pretty=changelogto be equivalent to runninggitlog "--pretty=format:*%H%s".Note that an alias with the same name as a built-in formatwill be silently ignored.

promisor.quiet

If set to "true" assume--quiet when fetching additionalobjects for a partial clone.

promisor.advertise

If set to "true", a server will use the "promisor-remote"capability, seegitprotocol-v2(5), to advertise thepromisor remotes it is using, if it uses some. Default is"false", which means the "promisor-remote" capability is notadvertised.

promisor.sendFields

A comma or space separated list of additional remote relatedfield names. A server sends these field names and theassociated field values from its configuration whenadvertising its promisor remotes using the "promisor-remote"capability, seegitprotocol-v2(5). Currently, only the"partialCloneFilter" and "token" field names are supported.

partialCloneFilter

contains the partial clone filterused for the remote.

token

contains an authentication token for the remote.

When a field name is part of this list and a corresponding"remote.foo.<field-name>" config variable is set on the server to anon-empty value, then the field name and value are sent whenadvertising the promisor remote "foo".

This list has no effect unless the "promisor.advertise" configvariable is set to "true", and the "name" and "url" fields are alwaysadvertised regardless of this setting.

promisor.acceptFromServer

If set to "all", a client will accept all the promisor remotesa server might advertise using the "promisor-remote"capability. If set to "knownName" the client will acceptpromisor remotes which are already configured on the clientand have the same name as those advertised by the client. Thisis not very secure, but could be used in a corporate setupwhere servers and clients are trusted to not switch name andURLs. If set to "knownUrl", the client will accept promisorremotes which have both the same name and the same URLconfigured on the client as the name and URL advertised by theserver. This is more secure than "all" or "knownName", so itshould be used if possible instead of those options. Defaultis "none", which means no promisor remote advertised by aserver will be accepted. By accepting a promisor remote, theclient agrees that the server might omit objects that arelazily fetchable from this promisor remote from its responsesto "fetch" and "clone" requests from the client. Name and URLcomparisons are case sensitive. Seegitprotocol-v2(5).

promisor.checkFields

A comma or space separated list of additional remote relatedfield names. A client checks if the values of these fieldstransmitted by a server correspond to the values of thesefields in its own configuration before accepting a promisorremote. Currently, "partialCloneFilter" and "token" are theonly supported field names.

If one of these field names (e.g., "token") is being checked for anadvertised promisor remote (e.g., "foo"), three conditions must be metfor the check of this specific field to pass:

1. The corresponding local configuration (e.g.,remote.foo.token)must be set.

2. The server must advertise the "token" field for remote "foo".

3. The value of the locally configuredremote.foo.token must exactlymatch the value advertised by the server for the "token" field.

   If any of these conditions is not met for any field name listed inpromisor.checkFields, the advertised remote "foo" is rejected.

   For the "partialCloneFilter" field, this allows the client to ensurethat the server’s filter matches what it expects locally, preventinginconsistencies in filtering behavior. For the "token" field, this canbe used to verify that authentication credentials match expectedvalues.

   Field values are compared case-sensitively.

   The "name" and "url" fields are always checked according to thepromisor.acceptFromServer policy, independently of this setting.

   The field names and values should be passed by the server through the"promisor-remote" capability by using thepromisor.sendFields configvariable. The fields are checked only if thepromisor.acceptFromServer config variable is not set to "None". Ifset to "None", this config variable has no effect. Seegitprotocol-v2(5).

protocol.allow

If set, provide a user defined default policy for all protocols whichdon’t explicitly have a policy (protocol.<name>.allow). By default,if unset, known-safe protocols (http, https, git, ssh) have adefault policy ofalways, known-dangerous protocols (ext) have adefault policy ofnever, and all other protocols (including file)have a default policy ofuser. Supported policies:

• always - protocol is always able to be used.

• never - protocol is never able to be used.

• user - protocol is only able to be used whenGIT_PROTOCOL_FROM_USER iseither unset or has a value of 1. This policy should be used when you want aprotocol to be directly usable by the user but don’t want it used by commands whichexecute clone/fetch/push commands without user input, e.g. recursivesubmodule initialization.

protocol.<name>.allow

Set a policy to be used by protocol<name> with clone/fetch/pushcommands. Seeprotocol.allow above for the available policies.

The protocol names currently used by git are:

• file: any local file-based path (includingfile:// URLs,or local paths)

• git: the anonymous git protocol over a direct TCPconnection (or proxy, if configured)

• ssh: git over ssh (includinghost:path syntax,ssh://, etc).

• http: git over http, both "smart http" and "dumb http".Note that this doesnot includehttps; if you want to configureboth, you must do so individually.

• any external helpers are named by their protocol (e.g., usehg to allow thegit-remote-hg helper)

protocol.version

If set, clients will attempt to communicate with a serverusing the specified protocol version. If the server doesnot support it, communication falls back to version 0.If unset, the default is2.Supported versions:

• 0 - the original wire protocol.

• 1 - the original wire protocol with the addition of a version stringin the initial response from the server.

• 2 - Wire protocol version 2, seegitprotocol-v2(5).

pull.ff

By default, Git does not create an extra merge commit when merginga commit that is a descendant of the current commit. Instead, thetip of the current branch is fast-forwarded. When set tofalse,this variable tells Git to create an extra merge commit in sucha case (equivalent to giving the--no-ff option from the commandline). When set toonly, only such fast-forward merges areallowed (equivalent to giving the--ff-only option from thecommand line). This setting overridesmerge.ff when pulling.

pull.rebase

When true, rebase branches on top of the fetched branch, insteadof merging the default branch from the default remote when "gitpull" is run. See "branch.<name>.rebase" for setting this on aper-branch basis.

Whenmerges (or justm), pass the--rebase-merges option togit rebaseso that the local merge commits are included in the rebase (seegit-rebase(1) for details).

When the value isinteractive (or justi), the rebase is run in interactivemode.

NOTE: this is a possibly dangerous operation; donot useit unless you understand the implications (seegit-rebase(1)for details).

pull.octopus

The default merge strategy to use when pulling multiple branchesat once.

pull.autoStash

When set to true, automatically create a temporary stash entryto record the local changes before the operation begins, andrestore them after the operation completes. When your "gitpull" rebases (instead of merges), this may be convenient, sinceunlike merging pull that tolerates local changes that do notinterfere with the merge, rebasing pull refuses to work with anylocal changes.

Ifpull.autostash is set (either to true or false),merge.autostash andrebase.autostash are ignored. Ifpull.autostash is not set at all, depending on the value ofpull.rebase,merge.autostash orrebase.autostash is usedinstead. Can be overridden by the--[no-]autostash command lineoption.

pull.twohead

The default merge strategy to use when pulling a single branch.

push.autoSetupRemote

If set to "true" assume--set-upstream on default push when noupstream tracking exists for the current branch; this optiontakes effect with push.default optionssimple,upstream,andcurrent. It is useful if by default you want new branchesto be pushed to the default remote (like the behavior ofpush.default=current) and you also want the upstream trackingto be set. Workflows most likely to benefit from this option aresimple central workflows where all branches are expected tohave the same name on the remote.

push.default

Defines the actiongitpush should take if no refspec isgiven (whether from the command-line, config, or elsewhere).Different values are well-suited forspecific workflows; for instance, in a purely central workflow(i.e. the fetch source is equal to the push destination),upstream is probably what you want. Possible values are:

• nothing - do not push anything (error out) unless a refspec isgiven. This is primarily meant for people who want toavoid mistakes by always being explicit.

• current - push the current branch to update a branch with the samename on the receiving end. Works in both central and non-centralworkflows.

• upstream - push the current branch back to the branch whosechanges are usually integrated into the current branch (which iscalled@{upstream}). This mode only makes sense if you arepushing to the same repository you would normally pull from(i.e. central workflow).

• tracking - This is a deprecated synonym forupstream.

• simple - push the current branch with the same name on the remote.

  If you are working on a centralized workflow (pushing to the same repository youpull from, which is typicallyorigin), then you need to configure an upstreambranch with the same name.

  This mode is the default since Git 2.0, and is the safest option suited forbeginners.

• matching - push all branches having the same name on both ends.This makes the repository you are pushing to remember the set ofbranches that will be pushed out (e.g. if you always pushmaintandmaster there and no other branches, the repository you pushto will have these two branches, and your localmaint andmaster will be pushed there).

  To use this mode effectively, you have to make sureall thebranches you would push out are ready to be pushed out beforerunninggit push, as the whole point of this mode is to allow youto push all of the branches in one go. If you usually finish workon only one branch and push out the result, while other branches areunfinished, this mode is not for you. Also this mode is notsuitable for pushing into a shared central repository, as otherpeople may add new branches there, or update the tip of existingbranches outside your control.

  This used to be the default, but not since Git 2.0 (simple is thenew default).

push.followTags

If set to true, enable--follow-tags option by default. Youmay override this configuration at time of push by specifying--no-follow-tags.

push.gpgSign

May be set to a boolean value, or the stringif-asked. A truevalue causes all pushes to be GPG signed, as if--signed ispassed togit-push(1). The stringif-asked causespushes to be signed if the server supports it, as if--signed=if-asked is passed togit push. A false value mayoverride a value from a lower-priority config file. An explicitcommand-line flag always overrides this config option.

push.pushOption

When no--push-option=<option> argument is given from thecommand line,gitpush behaves as if each <value> ofthis variable is given as--push-option=<value>.

This is a multi-valued variable, and an empty value can be used in ahigher priority configuration file (e.g. .git/config in arepository) to clear the values inherited from a lower priorityconfiguration files (e.g.$HOME/.gitconfig).

Example:/etc/gitconfig  push.pushoption = a  push.pushoption = b~/.gitconfig  push.pushoption = crepo/.git/config  push.pushoption =  push.pushoption = bThis will result in only b (a and c are cleared).

push.recurseSubmodules

May be "check", "on-demand", "only", or "no", with the same behavioras that of "push --recurse-submodules".If not set,no is used by default, unlesssubmodule.recurse isset (in which case atrue value meanson-demand).

push.useForceIfIncludes

If set to "true", it is equivalent to specifying--force-if-includes as an option togit-push(1)in the command line. Adding--no-force-if-includes at thetime of push overrides this configuration setting.

push.negotiate

If set to "true", attempt to reduce the size of the packfilesent by rounds of negotiation in which the client and theserver attempt to find commits in common. If "false", Git willrely solely on the server’s ref advertisement to find commitsin common.

push.useBitmaps

If set to "false", disable use of bitmaps for "git push" even ifpack.useBitmaps is "true", without preventing other git operationsfrom using bitmaps. Default is true.

rebase.backend

Default backend to use for rebasing. Possible choices areapply ormerge. In the future, if the merge backend gainsall remaining capabilities of the apply backend, this settingmay become unused.

rebase.stat

Whether to show a diffstat of what changed upstream since the lastrebase. False by default.

rebase.autoSquash

If set to true, enable the--autosquash option ofgit-rebase(1) by default for interactive mode.This can be overridden with the--no-autosquash option.

rebase.autoStash

When set to true, automatically create a temporary stash entrybefore the operation begins, and apply it after the operationends. This means that you can run rebase on a dirty worktree.However, use with care: the final stash application after asuccessful rebase might result in non-trivial conflicts.This option can be overridden by the--no-autostash and--autostash options ofgit-rebase(1).Defaults to false.

rebase.updateRefs

If set to true enable--update-refs option by default.

rebase.missingCommitsCheck

If set to "warn", git rebase -i will print a warning if somecommits are removed (e.g. a line was deleted), however therebase will still proceed. If set to "error", it will printthe previous warning and stop the rebase,git rebase--edit-todo can then be used to correct the error. If set to"ignore", no checking is done.To drop a commit without warning or error, use thedropcommand in the todo list.Defaults to "ignore".

rebase.instructionFormat

A format string, as specified ingit-log(1), to be used for thetodo list during an interactive rebase. The format willautomatically have the commit hash prepended to the format.

rebase.abbreviateCommands

If set to true,gitrebase will use abbreviated command names in thetodo list resulting in something like this:

        p deadbee The oneline of the commit        p fa1afe1 The oneline of the next commit        ...

instead of:

        pick deadbee The oneline of the commit        pick fa1afe1 The oneline of the next commit        ...

Defaults to false.

rebase.rescheduleFailedExec

Automatically rescheduleexec commands that failed. This only makessense in interactive mode (or when an--exec option was provided).This is the same as specifying the--reschedule-failed-exec option.

rebase.forkPoint

If set to false set--no-fork-point option by default.

rebase.rebaseMerges

Whether and how to set the--rebase-merges option by default. Canberebase-cousins,no-rebase-cousins, or a boolean. Setting totrue or tono-rebase-cousins is equivalent to--rebase-merges=no-rebase-cousins, setting torebase-cousins isequivalent to--rebase-merges=rebase-cousins, and setting to false isequivalent to--no-rebase-merges. Passing--rebase-merges on thecommand line, with or without an argument, overrides anyrebase.rebaseMerges configuration.

rebase.maxLabelLength

When generating label names from commit subjects, truncate the names tothis length. By default, the names are truncated to a little less thanNAME_MAX (to allow e.g. .lock files to be written for thecorresponding loose refs).

receive.advertiseAtomic

By default, git-receive-pack will advertise the atomic pushcapability to its clients. If you don’t want to advertise thiscapability, set this variable to false.

receive.advertisePushOptions

When set to true, git-receive-pack will advertise the push optionscapability to its clients. False by default.

receive.autogc

By default, git-receive-pack will run "git maintenance run --auto" afterreceiving data from git-push and updating refs. You can stopit by setting this variable to false.

receive.certNonceSeed

By setting this variable to a string,gitreceive-packwill accept agitpush--signed and verify it by usinga "nonce" protected by HMAC using this string as a secretkey.

receive.certNonceSlop

When agitpush--signed sends a push certificate with a"nonce" that was issued by a receive-pack serving the samerepository within this many seconds, export the "nonce"found in the certificate toGIT_PUSH_CERT_NONCE to thehooks (instead of what the receive-pack asked the sendingside to include). This may allow writing checks inpre-receive andpost-receive a bit easier. Instead ofcheckingGIT_PUSH_CERT_NONCE_SLOP environment variablethat records by how many seconds the nonce is stale todecide if they want to accept the certificate, they onlycan checkGIT_PUSH_CERT_NONCE_STATUS isOK.

receive.fsckObjects

If it is set to true, git-receive-pack will check all receivedobjects. Seetransfer.fsckObjects for what’s checked.Defaults to false. If not set, the value oftransfer.fsckObjects is used instead.

receive.fsck.<msg-id>

Acts likefsck.<msg-id>, but is used bygit-receive-pack(1) instead ofgit-fsck(1). See thefsck.<msg-id> documentation fordetails.

receive.fsck.skipList

Acts likefsck.skipList, but is used bygit-receive-pack(1) instead ofgit-fsck(1). See thefsck.skipList documentation fordetails.

receive.keepAlive

After receiving the pack from the client,receive-pack mayproduce no output (if--quiet was specified) while processingthe pack, causing some networks to drop the TCP connection.With this option set, ifreceive-pack does not transmitany data in this phase forreceive.keepAlive seconds, it willsend a short keepalive packet. The default is 5 seconds; setto 0 to disable keepalives entirely.

receive.unpackLimit

If the number of objects received in a push is below thislimit then the objects will be unpacked into loose objectfiles. However if the number of received objects equals orexceeds this limit then the received pack will be stored asa pack, after adding any missing delta bases. Storing thepack from a push can make the push operation complete faster,especially on slow filesystems. If not set, the value oftransfer.unpackLimit is used instead.

receive.maxInputSize

If the size of the incoming pack stream is larger than thislimit, then git-receive-pack will error out, instead ofaccepting the pack file. If not set or set to 0, then the sizeis unlimited.

receive.denyDeletes

If set to true, git-receive-pack will deny a ref update that deletesthe ref. Use this to prevent such a ref deletion via a push.

receive.denyDeleteCurrent

If set to true, git-receive-pack will deny a ref update thatdeletes the currently checked out branch of a non-bare repository.

receive.denyCurrentBranch

If set to true or "refuse", git-receive-pack will deny a ref updateto the currently checked out branch of a non-bare repository.Such a push is potentially dangerous because it brings the HEADout of sync with the index and working tree. If set to "warn",print a warning of such a push to stderr, but allow the push toproceed. If set to false or "ignore", allow such pushes with nomessage. Defaults to "refuse".

Another option is "updateInstead" which will update the workingtree if pushing into the current branch. This option isintended for synchronizing working directories when one side is not easilyaccessible via interactive ssh (e.g. a live web site, hence the requirementthat the working directory be clean). This mode also comes in handy whendeveloping inside a VM to test and fix code on different Operating Systems.

By default, "updateInstead" will refuse the push if the working tree orthe index have any difference from the HEAD, but thepush-to-checkouthook can be used to customize this. Seegithooks(5).

receive.denyNonFastForwards

If set to true, git-receive-pack will deny a ref update which isnot a fast-forward. Use this to prevent such an update via a push,even if that push is forced. This configuration variable isset when initializing a shared repository.

receive.hideRefs

This variable is the same astransfer.hideRefs, but appliesonly toreceive-pack (and so affects pushes, but not fetches).An attempt to update or delete a hidden ref bygitpush isrejected.

receive.procReceiveRefs

This is a multi-valued variable that defines reference prefixesto match the commands inreceive-pack. Commands matching theprefixes will be executed by an external hook "proc-receive",instead of the internalexecute_commands function. If thisvariable is not defined, the "proc-receive" hook will never beused, and all commands will be executed by the internalexecute_commands function.

For example, if this variable is set to "refs/for", pushing to referencesuch as "refs/for/master" will not create or update a reference named"refs/for/master", but may create or update a pull request directly byrunning the hook "proc-receive".

Optional modifiers can be provided in the beginning of the value to filtercommands for specific actions: create (a), modify (m), delete (d).A ! can be included in the modifiers to negate the reference prefix entry.E.g.:

git config --system --add receive.procReceiveRefs ad:refs/headsgit config --system --add receive.procReceiveRefs !:refs/heads

receive.updateServerInfo

If set to true, git-receive-pack will run git-update-server-infoafter receiving data from git-push and updating refs.

receive.shallowUpdate

If set to true, .git/shallow can be updated when new refsrequire new shallow roots. Otherwise those refs are rejected.

reftable.blockSize

The size in bytes used by the reftable backend when writing blocks.The block size is determined by the writer, and does not have to be apower of 2. The block size must be larger than the longest referencename or log entry used in the repository, as references cannot spanblocks.

Powers of two that are friendly to the virtual memory system orfilesystem (such as 4kB or 8kB) are recommended. Larger sizes (64kB) canyield better compression, with a possible increased cost incurred byreaders during access.

The largest block size is16777215 bytes (15.99 MiB). The default value is4096 bytes (4kB). A value of0 will use the default value.

reftable.restartInterval

The interval at which to create restart points. The reftable backenddetermines the restart points at file creation. Every 16 may bemore suitable for smaller block sizes (4k or 8k), every 64 for largerblock sizes (64k).

More frequent restart points reduces prefix compression and increasesspace consumed by the restart table, both of which increase file size.

Less frequent restart points makes prefix compression more effective,decreasing overall file size, with increased penalties for readerswalking through more records after the binary search step.

A maximum of65535 restart points per block is supported.

The default value is to create restart points every 16 records. A value of0will use the default value.

reftable.indexObjects

Whether the reftable backend shall write object blocks. Object blocksare a reverse mapping of object ID to the references pointing to them.

The default value istrue.

reftable.geometricFactor

Whenever the reftable backend appends a new table to the stack, itperforms auto compaction to ensure that there is only a handful oftables. The backend does this by ensuring that tables form a geometricsequence regarding the respective sizes of each table.

By default, the geometric sequence uses a factor of 2, meaning that for anytable, the next-biggest table must at least be twice as big. A maximum factorof 256 is supported.

reftable.lockTimeout

Whenever the reftable backend appends a new table to the stack, it hasto lock the central "tables.list" file before updating it. This configcontrols how long the process will wait to acquire the lock in caseanother process has already acquired it. Value 0 means not to retry atall; -1 means to try indefinitely. Default is 100 (i.e., retry for100ms).

remote.pushDefault

The remote to push to by default. Overridesbranch.<name>.remote for all branches, and is overridden bybranch.<name>.pushRemote for specific branches.

remote.<name>.url

The URL of a remote repository. Seegit-fetch(1) orgit-push(1). A configured remote can have multiple URLs;in this case the first is used for fetching, and all are usedfor pushing (assuming noremote.<name>.pushurl is defined).Setting this key to the empty string clears the list of urls,allowing you to override earlier config.

remote.<name>.pushurl

The push URL of a remote repository. Seegit-push(1).If apushurl option is present in a configured remote, itis used for pushing instead ofremote.<name>.url. A configuredremote can have multiple push URLs; in this case a push goes toall of them. Setting this key to the empty string clears thelist of urls, allowing you to override earlier config.

remote.<name>.proxy

For remotes that require curl (http, https and ftp), the URL tothe proxy to use for that remote. Set to the empty string todisable proxying for that remote.

remote.<name>.proxyAuthMethod

For remotes that require curl (http, https and ftp), the method to use forauthenticating against the proxy in use (probably set inremote.<name>.proxy). Seehttp.proxyAuthMethod.

remote.<name>.fetch

The default set of "refspec" forgit-fetch(1). Seegit-fetch(1).

remote.<name>.push

The default set of "refspec" forgit-push(1). Seegit-push(1).

remote.<name>.mirror

If true, pushing to this remote will automatically behaveas if the--mirror option was given on the command line.

remote.<name>.skipDefaultUpdate

A deprecated synonym toremote.<name>.skipFetchAll (ifboth are set in the configuration files with differentvalues, the value of the last occurrence will be used).

remote.<name>.skipFetchAll

If true, this remote will be skipped when updatingusinggit-fetch(1), theupdate subcommand ofgit-remote(1), and ignored by the prefetch taskofgitmaintenance.

remote.<name>.receivepack

The default program to execute on the remote side when pushing. Seeoption --receive-pack ofgit-push(1).

remote.<name>.uploadpack

The default program to execute on the remote side when fetching. Seeoption --upload-pack ofgit-fetch-pack(1).

remote.<name>.tagOpt

Setting this value to --no-tags disables automatic tag following whenfetching from remote <name>. Setting it to --tags will fetch everytag from remote <name>, even if they are not reachable from remotebranch heads. Passing these flags directly togit-fetch(1) canoverride this setting. See options --tags and --no-tags ofgit-fetch(1).

remote.<name>.vcs

Setting this to a value <vcs> will cause Git to interact withthe remote with the git-remote-<vcs> helper.

remote.<name>.prune

When set to true, fetching from this remote by default will alsoremove any remote-tracking references that no longer exist on theremote (as if the--prune option was given on the command line).Overridesfetch.prune settings, if any.

remote.<name>.pruneTags

When set to true, fetching from this remote by default will alsoremove any local tags that no longer exist on the remote if pruningis activated in general viaremote.<name>.prune,fetch.prune or--prune. Overridesfetch.pruneTags settings, if any.

See alsoremote.<name>.prune and the PRUNING section ofgit-fetch(1).

remote.<name>.promisor

When set to true, this remote will be used to fetch promisorobjects.

remote.<name>.partialclonefilter

The filter that will be applied when fetching from thispromisor remote.Changing or clearing this value will only affect fetches for new commits.To fetch associated objects for commits already present in the local objectdatabase, use the--refetch option ofgit-fetch(1).

remote.<name>.serverOption

The default set of server options used when fetching from this remote.These server options can be overridden by the--server-option= commandline arguments.

This is a multi-valued variable, and an empty value can be used in a higherpriority configuration file (e.g. .git/config in a repository) to clearthe values inherited from a lower priority configuration files (e.g.$HOME/.gitconfig).

remote.<name>.followRemoteHEAD

Howgit-fetch(1) should handle updates toremotes/<name>/HEADwhen fetching using the configured refspecs of a remote.The default value is "create", which will createremotes/<name>/HEADif it exists on the remote, but not locally; this will not touch analready existing local reference. Setting it to "warn" will printa message if the remote has a different value than the local one;in case there is no local reference, it behaves like "create".A variant on "warn" is "warn-if-not-$branch", which behaves like"warn", but ifHEAD on the remote is$branch it will be silent.Setting it to "always" will silently updateremotes/<name>/HEAD tothe value on the remote. Finally, setting it to "never" will neverchange or create the local reference.

remotes.<group>

The list of remotes which are fetched by "git remote update<group>". Seegit-remote(1).

repack.useDeltaBaseOffset

By default,git-repack(1) creates packs that usedelta-base offset. If you need to share your repository withGit older than version 1.4.4, either directly or via a dumbprotocol such as http, then you need to set this option to"false" and repack. Access from old Git versions over thenative protocol are unaffected by this option.

repack.packKeptObjects

If set to true, makesgitrepack act as if--pack-kept-objects was passed. Seegit-repack(1) fordetails. Defaults tofalse normally, buttrue if a bitmapindex is being written (either via--write-bitmap-index orrepack.writeBitmaps).

repack.useDeltaIslands

If set to true, makesgitrepack act as if--delta-islandswas passed. Defaults tofalse.

repack.writeBitmaps

When true, git will write a bitmap index when packing allobjects to disk (e.g., whengitrepack-a is run). Thisindex can speed up the "counting objects" phase of subsequentpacks created for clones and fetches, at the cost of some diskspace and extra time spent on the initial repack. This hasno effect if multiple packfiles are created.Defaults to true on bare repos, false otherwise.

repack.updateServerInfo

If set to false,git-repack(1) will not rungit-update-server-info(1). Defaults to true. Can be overriddenwhen true by the-n option ofgit-repack(1).

repack.cruftWindow

repack.cruftWindowMemory

repack.cruftDepth

repack.cruftThreads

Parameters used bygit-pack-objects(1) when generatinga cruft pack and the respective parameters are not given overthe command line. See similarly namedpack.* configurationvariables for defaults and meaning.

repack.midxMustContainCruft

When set to true,git-repack(1) will unconditionally includecruft pack(s), if any, in the multi-pack index when invoked with--write-midx. When false, cruft packs are only included in the MIDXwhen necessary (e.g., because they might be required to form areachability closure with MIDX bitmaps). Defaults to true.

rerere.autoUpdate

When set to true,git-rerere updates the index with theresulting contents after it cleanly resolves conflicts usingpreviously recorded resolutions. Defaults to false.

rerere.enabled

Activate recording of resolved conflicts, so that identicalconflict hunks can be resolved automatically, should they beencountered again. By default,git-rerere(1) isenabled if there is anrr-cache directory under the$GIT_DIR, e.g. if "rerere" was previously used in therepository.

revert.reference

Setting this variable to true makesgitrevert behaveas if the--reference option is given.

safe.bareRepository

Specifies which bare repositories Git will work with. The currentlysupported values are:

• all: Git works with all bare repositories. This is the default.

• explicit: Git only works with bare repositories specified viathe top-level--git-dir command-line option, or theGIT_DIRenvironment variable (seegit(1)).

  If you do not use bare repositories in your workflow, then it may bebeneficial to setsafe.bareRepository toexplicit in your globalconfig. This will protect you from attacks that involve cloning arepository that contains a bare repository and running a Git commandwithin that directory.

  This config setting is only respected in protected configuration (seeSCOPES). This prevents untrusted repositories from tampering withthis value.

safe.directory

These config entries specify Git-tracked directories that areconsidered safe even if they are owned by someone other than thecurrent user. By default, Git will refuse to even parse a Gitconfig of a repository owned by someone else, let alone run itshooks, and this config setting allows users to specify exceptions,e.g. for intentionally shared repositories (see the--sharedoption ingit-init(1)).

This is a multi-valued setting, i.e. you can add more than one directoryviagitconfig--add. To reset the list of safe directories (e.g. tooverride any such directories specified in the system config), add asafe.directory entry with an empty value.

This config setting is only respected in protected configuration (seeSCOPES). This prevents untrusted repositories from tampering with thisvalue.

The value of this setting is interpolated, i.e.~/<path> expands to apath relative to the home directory and%(prefix)/<path> expands to apath relative to Git’s (runtime) prefix.

To completely opt-out of this security check, setsafe.directory to thestring*. This will allow all repositories to be treated as if theirdirectory was listed in thesafe.directory list. Ifsafe.directory=*is set in system config and you want to re-enable this protection, theninitialize your list with an empty value before listing the repositoriesthat you deem safe. Giving a directory with/* appended to it willallow access to all repositories under the named directory.

As explained, Git only allows you to access repositories owned byyourself, i.e. the user who is running Git, by default. When Gitis running asroot in a non Windows platform that provides sudo,however, git checks the SUDO_UID environment variable that sudo createsand will allow access to the uid recorded as its value in addition tothe id fromroot.This is to make it easy to perform a common sequence during installation"make && sudo make install". A git process running undersudo runs asroot but thesudo command exports the environment variable to recordwhich id the original user has.If that is not what you would prefer and want git to only trustrepositories that are owned by root instead, then you can removetheSUDO_UID variable from root’s environment before invoking git.

sendemail.identity

A configuration identity. When given, causes values in thesendemail.<identity> subsection to take precedence overvalues in thesendemail section. The default identity isthe value ofsendemail.identity.

sendemail.smtpEncryption

Seegit-send-email(1) for description. Note that thissetting is not subject to theidentity mechanism.

sendemail.smtpSSLCertPath

Path to ca-certificates (either a directory or a single file).Set it to an empty string to disable certificate verification.

sendemail.<identity>.*

Identity-specific versions of thesendemail.* parametersfound below, taking precedence over those when thisidentity is selected, through either the command-line orsendemail.identity.

sendemail.multiEdit

Iftrue (default), a single editor instance will be spawned to editfiles you have to edit (patches when--annotate is used, and thesummary when--compose is used). Iffalse, files will be edited oneafter the other, spawning a new editor each time.

sendemail.confirm

Sets the default for whether to confirm before sending. Must beone ofalways,never,cc,compose, orauto. See--confirmin thegit-send-email(1) documentation for the meaning of thesevalues.

sendemail.mailmap

Iftrue, makesgit-send-email(1) assume--mailmap,otherwise assume--no-mailmap.False by default.

sendemail.mailmap.file

The location of agit-send-email(1) specific augmentingmailmap file. The default mailmap andmailmap.file are loadedfirst. Thus, entries in this file take precedence over entries inthe default mailmap locations. Seegitmailmap(5).

sendemail.mailmap.blob

Likesendemail.mailmap.file, but consider the value as a referenceto a blob in the repository. Entries insendemail.mailmap.filetake precedence over entries here. Seegitmailmap(5).

sendemail.aliasesFile

To avoid typing long email addresses, point this to one or moreemail aliases files. You must also supplysendemail.aliasFileType.

sendemail.aliasFileType

Format of the file(s) specified in sendemail.aliasesFile. Must beone ofmutt,mailrc,pine,elm,gnus, orsendmail.

What an alias file in each format looks like can be found inthe documentation of the email program of the same name. Thedifferences and limitations from the standard formats aredescribed below:

sendmail

• Quoted aliases and quoted addresses are not supported: lines thatcontain a " symbol are ignored.

• Redirection to a file (/path/name) or pipe (|command) is notsupported.

• File inclusion (:include:/path/name) is not supported.

• Warnings are printed on the standard error output for anyexplicitly unsupported constructs, and any other lines that are notrecognized by the parser.

sendemail.annotate

sendemail.bcc

sendemail.cc

sendemail.ccCmd

sendemail.chainReplyTo

sendemail.envelopeSender

sendemail.from

sendemail.headerCmd

sendemail.signedOffByCc

sendemail.smtpPass

sendemail.suppressCc

sendemail.suppressFrom

sendemail.to

sendemail.toCmd

sendemail.smtpDomain

sendemail.smtpServer

sendemail.smtpServerPort

sendemail.smtpServerOption

sendemail.smtpUser

sendemail.imapSentFolder

sendemail.useImapOnly

sendemail.thread

sendemail.transferEncoding

sendemail.validate

sendemail.xmailer

These configuration variables all provide a default forgit-send-email(1) command-line options. See itsdocumentation for details.

sendemail.outlookidfix

Iftrue, makesgit-send-email(1) assume--outlook-id-fix,and iffalse assume--no-outlook-id-fix. If not specified, it willbehave the same way as if--outlook-id-fix is not specified.

sendemail.signedOffCc (deprecated)

Deprecated alias forsendemail.signedOffByCc.

sendemail.smtpBatchSize

Number of messages to be sent per connection, after that a reloginwill happen. If the value is0 or undefined, send all messages inone connection.See also the--batch-size option ofgit-send-email(1).

sendemail.smtpReloginDelay

Seconds to wait before reconnecting to the smtp server.See also the--relogin-delay option ofgit-send-email(1).

sendemail.forbidSendmailVariables

To avoid common misconfiguration mistakes,git-send-email(1)will abort with a warning if any configuration options forsendmailexist. Set this variable to bypass the check.

sequence.editor

Text editor used bygitrebase-i for editing the rebase instruction file.The value is meant to be interpreted by the shell when it is used.It can be overridden by theGIT_SEQUENCE_EDITOR environment variable.When not configured, the default commit message editor is used instead.

showBranch.default

The default set of branches forgit-show-branch(1).Seegit-show-branch(1).

sparse.expectFilesOutsideOfPatterns

Typically with sparse checkouts, files not matching anysparsity patterns are marked with a SKIP_WORKTREE bit in theindex and are missing from the working tree. Accordingly, Gitwill ordinarily check whether files with the SKIP_WORKTREE bitare in fact present in the working tree contrary toexpectations. If Git finds any, it marks those paths aspresent by clearing the relevant SKIP_WORKTREE bits. Thisoption can be used to tell Git that suchpresent-despite-skipped files are expected and to stopchecking for them.

The default isfalse, which allows Git to automatically recoverfrom the list of files in the index and working tree falling out ofsync.

Set this totrue if you are in a setup where some external factorrelieves Git of the responsibility for maintaining the consistencybetween the presence of working tree files and sparsity patterns. Forexample, if you have a Git-aware virtual file system that has a robustmechanism for keeping the working tree and the sparsity patterns up todate based on access patterns.

Regardless of this setting, Git does not check forpresent-despite-skipped files unless sparse checkout is enabled, sothis config option has no effect unlesscore.sparseCheckout istrue.

splitIndex.maxPercentChange

When the split index feature is used, this specifies thepercent of entries the split index can contain compared to thetotal number of entries in both the split index and the sharedindex before a new shared index is written.The value should be between 0 and 100. If the value is 0, thena new shared index is always written; if it is 100, a newshared index is never written.By default, the value is 20, so a new shared index is writtenif the number of entries in the split index would be greaterthan 20 percent of the total number of entries.Seegit-update-index(1).

splitIndex.sharedIndexExpire

When the split index feature is used, shared index files thatwere not modified since the time this variable specifies willbe removed when a new shared index file is created. The value"now" expires all entries immediately, and "never" suppressesexpiration altogether.The default value is "2.weeks.ago".Note that a shared index file is considered modified (for thepurpose of expiration) each time a new split-index file iseither created based on it or read from it.Seegit-update-index(1).

ssh.variant

By default, Git determines the command line arguments to usebased on the basename of the configured SSH command (configuredusing the environment variableGIT_SSH orGIT_SSH_COMMAND orthe config settingcore.sshCommand). If the basename isunrecognized, Git will attempt to detect support of OpenSSHoptions by first invoking the configured SSH command with the-G (print configuration) option and will subsequently useOpenSSH options (if that is successful) or no options besidesthe host and remote command (if it fails).

The config variablessh.variant can be set to override this detection.Valid values aressh (to use OpenSSH options),plink,putty,tortoiseplink,simple (no options except the host and remote command).The default auto-detection can be explicitly requested using the valueauto. Any other value is treated asssh. This setting can also beoverridden via the environment variableGIT_SSH_VARIANT.

The current command-line parameters used for each variant are asfollows:

• ssh - [-p port] [-4] [-6] [-o option] [username@]host command

• simple - [username@]host command

• plink orputty - [-P port] [-4] [-6] [username@]host command

• tortoiseplink - [-P port] [-4] [-6] -batch [username@]host command

Except for thesimple variant, command-line parameters are likely tochange as git gains new features.

stash.index

If this is set to true,gitstashapply andgitstashpop willbehave as if--index was supplied. Defaults to false.See the descriptions ingit-stash(1).

This also affects invocations ofgit-stash(1) via--autostash fromcommands likegit-merge(1),git-rebase(1), andgit-pull(1).

stash.showIncludeUntracked

If this is set to true, thegitstashshow command will showthe untracked files of a stash entry. Defaults to false. See the description of the 'show' command ingit-stash(1).

stash.showPatch

If this is set to true, thegitstashshow command without anoption will show the stash entry in patch form. Defaults to false.See the description of the 'show' command ingit-stash(1).

stash.showStat

If this is set to true, thegitstashshow command without anoption will show a diffstat of the stash entry. Defaults to true.See the description of the 'show' command ingit-stash(1).

status.relativePaths

By default,git-status(1) shows paths relative to thecurrent directory. Setting this variable tofalse shows pathsrelative to the repository root (this was the default for Gitprior to v1.5.4).

status.short

Set to true to enable --short by default ingit-status(1).The option --no-short takes precedence over this variable.

status.branch

Set to true to enable --branch by default ingit-status(1).The option --no-branch takes precedence over this variable.

status.aheadBehind

Set to true to enable--ahead-behind and false to enable--no-ahead-behind by default ingit-status(1) fornon-porcelain status formats. Defaults to true.

status.displayCommentPrefix

If set to true,git-status(1) will insert a commentprefix before each output line (starting withcore.commentChar, i.e. # by default). This was thebehavior ofgit-status(1) in Git 1.8.4 and previous.Defaults to false.

status.renameLimit

The number of files to consider when performing rename detectioningit-status(1) andgit-commit(1). Defaults tothe value of diff.renameLimit.

status.renames

Whether and how Git detects renames ingit-status(1) andgit-commit(1) . If set to "false", rename detection isdisabled. If set to "true", basic rename detection is enabled.If set to "copies" or "copy", Git will detect copies, as well.Defaults to the value of diff.renames.

status.showStash

If set to true,git-status(1) will display the number ofentries currently stashed away.Defaults to false.

status.showUntrackedFiles

By default,git-status(1) andgit-commit(1) showfiles which are not currently tracked by Git. Directories whichcontain only untracked files, are shown with the directory nameonly. Showing untracked files means that Git needs to lstat() allthe files in the whole repository, which might be slow on somesystems. So, this variable controls how the commands displaythe untracked files. Possible values are:

• no - Show no untracked files.

• normal - Show untracked files and directories.

• all - Show also individual files in untracked directories.

If this variable is not specified, it defaults tonormal.All usual spellings for Boolean valuetrue are taken asnormalandfalse asno.This variable can be overridden with the -u|--untracked-files optionofgit-status(1) andgit-commit(1).

status.submoduleSummary

Defaults to false.If this is set to a non-zero number or true (identical to -1 or anunlimited number), the submodule summary will be enabled and asummary of commits for modified submodules will be shown (see--summary-limit option ofgit-submodule(1)). Please notethat the summary output command will be suppressed for allsubmodules whendiff.ignoreSubmodules is set toall or onlyfor those submodules wheresubmodule.<name>.ignore=all. The onlyexception to that rule is that status and commit will show stagedsubmodule changes. Toalso view the summary for ignored submodules you can either usethe --ignore-submodules=dirty command-line option or thegitsubmodule summary command, which shows a similar output but doesnot honor these settings.

submodule.<name>.url

The URL for a submodule. This variable is copied from the .gitmodulesfile to the git config viagit submodule init. The user can changethe configured URL before obtaining the submodule viagit submoduleupdate. If neither submodule.<name>.active nor submodule.active areset, the presence of this variable is used as a fallback to indicatewhether the submodule is of interest to git commands.Seegit-submodule(1) andgitmodules(5) for details.

submodule.<name>.update

The method by which a submodule is updated bygit submodule update,which is the only affected command, others such asgit checkout --recurse-submodules are unaffected. It exists forhistorical reasons, whengit submodule was the only command tointeract with submodules; settings likesubmodule.activeandpull.rebase are more specific. It is populated bygitsubmoduleinit from thegitmodules(5) file.See description ofupdate command ingit-submodule(1).

submodule.<name>.branch

The remote branch name for a submodule, used bygitsubmoduleupdate--remote. Set this option to override the value found inthe .gitmodules file. Seegit-submodule(1) andgitmodules(5) for details.

submodule.<name>.fetchRecurseSubmodules

This option can be used to control recursive fetching of thissubmodule. It can be overridden by using the --[no-]recurse-submodulescommand-line option to "git fetch" and "git pull".This setting will override that from in thegitmodules(5)file.

submodule.<name>.ignore

Defines under what circumstances "git status" and the diff family showa submodule as modified. When set to "all", it will never be consideredmodified (but it will nonetheless show up in the output of status andcommit when it has been staged), "dirty" will ignore all changesto the submodule’s work tree andtakes only differences between the HEAD of the submodule and the commitrecorded in the superproject into account. "untracked" will additionallylet submodules with modified tracked files in their work tree show up.Using "none" (the default when this option is not set) also showssubmodules that have untracked files in their work tree as changed.This setting overrides any setting made in .gitmodules for this submodule,both settings can be overridden on the command line by using the"--ignore-submodules" option. Thegit submodule commands are notaffected by this setting.

submodule.<name>.active

Boolean value indicating if the submodule is of interest to gitcommands. This config option takes precedence over thesubmodule.active config option. Seegitsubmodules(7) fordetails.

submodule.active

A repeated field which contains a pathspec used to match against asubmodule’s path to determine if the submodule is of interest to gitcommands. Seegitsubmodules(7) for details.

submodule.recurse

A boolean indicating if commands should enable the--recurse-submodulesoption by default. Defaults to false.

When set to true, it can be deactivated via the--no-recurse-submodules option. Note that some Git commandslacking this option may call some of the above commands affected bysubmodule.recurse; for instancegitremoteupdate will callgitfetch but does not have a--no-recurse-submodules option.For these commands a workaround is to temporarily change theconfiguration value by usinggit-csubmodule.recurse=0.

The following list shows the commands that accept--recurse-submodules and whether they are supported by thissetting.

• checkout,fetch,grep,pull,push,read-tree,reset,restore andswitch are always supported.

• clone andls-files are not supported.

• branch is supported only ifsubmodule.propagateBranches isenabled

submodule.propagateBranches

[EXPERIMENTAL] A boolean that enables branching support whenusing--recurse-submodules orsubmodule.recurse=true.Enabling this will allow certain commands to accept--recurse-submodules and certain commands that already accept--recurse-submodules will now consider branches.Defaults to false.

submodule.fetchJobs

Specifies how many submodules are fetched/cloned at the same time.A positive integer allows up to that number of submodules fetchedin parallel. A value of 0 will give some reasonable default.If unset, it defaults to 1.

submodule.alternateLocation

Specifies how the submodules obtain alternates when submodules arecloned. Possible values areno,superproject.By defaultno is assumed, which doesn’t add references. When thevalue is set tosuperproject the submodule to be cloned computesits alternates location relative to the superprojects alternate.

submodule.alternateErrorStrategy

Specifies how to treat errors with the alternates for a submoduleas computed viasubmodule.alternateLocation. Possible values areignore,info,die. Default isdie. Note that if set toignoreorinfo, and if there is an error with the computed alternate, theclone proceeds as if no alternate was specified.

tag.forceSignAnnotated

A boolean to specify whether annotated tags created should be GPG signed.If--annotate is specified on the command line, it takesprecedence over this option.

tag.sort

This variable controls the sort ordering of tags when displayed bygit-tag(1).Without the--sort=<value> option provided, the value of this variable willbe used as the default.

tag.gpgSign

A boolean to specify whether all tags should be GPG signed.Use of this option when running in an automated script canresult in a large number of tags being signed. It is thereforeconvenient to use an agent to avoid typing your GPG passphraseseveral times. Note that this option doesn’t affect tag signingbehavior enabled by-u<keyid> or--local-user=<keyid> options.

tar.umask

This variable can be used to restrict the permission bits oftar archive entries. The default is 0002, which turns off theworld write bit. The special value "user" indicates that thearchiving user’s umask will be used instead. See umask(2) andgit-archive(1).

Trace2 config settings are only read from the system and globalconfig files; repository local and worktree config files and-ccommand line arguments are not respected.

trace2.normalTarget

This variable controls the normal target destination.It may be overridden by theGIT_TRACE2 environment variable.The following table shows possible values.

trace2.perfTarget

This variable controls the performance target destination.It may be overridden by theGIT_TRACE2_PERF environment variable.The following table shows possible values.

trace2.eventTarget

This variable controls the event target destination.It may be overridden by theGIT_TRACE2_EVENT environment variable.The following table shows possible values.

• 0 orfalse - Disables the target.

• 1 ortrue - Writes toSTDERR.

• [2-9] - Writes to the already opened file descriptor.

• <absolute-pathname> - Writes to the file in append mode. If the targetalready exists and is a directory, the traces will be written to files (oneper process) underneath the given directory.

• af_unix:[<socket-type>:]<absolute-pathname> - Write to aUnix DomainSocket (on platforms that support them). Sockettype can be eitherstream ordgram; if omitted Git willtry both.

trace2.normalBrief

Boolean. When truetime,filename, andline fields areomitted from normal output. May be overridden by theGIT_TRACE2_BRIEF environment variable. Defaults to false.

trace2.perfBrief

Boolean. When truetime,filename, andline fields areomitted from PERF output. May be overridden by theGIT_TRACE2_PERF_BRIEF environment variable. Defaults to false.

trace2.eventBrief

Boolean. When truetime,filename, andline fields areomitted from event output. May be overridden by theGIT_TRACE2_EVENT_BRIEF environment variable. Defaults to false.

trace2.eventNesting

Integer. Specifies desired depth of nested regions in theevent output. Regions deeper than this value will beomitted. May be overridden by theGIT_TRACE2_EVENT_NESTINGenvironment variable. Defaults to 2.

trace2.configParams

A comma-separated list of patterns of "important" configsettings that should be recorded in the trace2 output.For example,core.*,remote.*.url would cause the trace2output to contain events listing each configured remote.May be overridden by theGIT_TRACE2_CONFIG_PARAMS environmentvariable. Unset by default.

trace2.envVars

A comma-separated list of "important" environment variables that shouldbe recorded in the trace2 output. For example,GIT_HTTP_USER_AGENT,GIT_CONFIG would cause the trace2 output tocontain events listing the overrides for HTTP user agent and thelocation of the Git configuration file (assuming any are set). May beoverridden by theGIT_TRACE2_ENV_VARS environment variable. Unset bydefault.

trace2.destinationDebug

Boolean. When true Git will print error messages when atrace target destination cannot be opened for writing.By default, these errors are suppressed and tracing issilently disabled. May be overridden by theGIT_TRACE2_DST_DEBUG environment variable.

trace2.maxFiles

Integer. When writing trace files to a target directory, do notwrite additional traces if doing so would exceed this many files. Instead,write a sentinel file that will block further tracing to thisdirectory. Defaults to 0, which disables this check.

trailer.separators

This option tells which characters are recognized as trailerseparators. By default only: is recognized as a trailerseparator, except that= is always accepted on the commandline for compatibility with other git commands.

The first character given by this option will be the default characterused when another separator is not specified in the config for thistrailer.

For example, if the value for this option is "%=$", then only linesusing the format<key><sep><value> with <sep> containing%,=or$ and then spaces will be considered trailers. And% will bethe default separator used, so by default trailers will appear like:<key>% <value> (one percent sign and one space will appear betweenthe key and the value).

trailer.where

This option tells where a new trailer will be added.

This can beend, which is the default,start,after orbefore.

If it isend, then each new trailer will appear at the end of theexisting trailers.

If it isstart, then each new trailer will appear at the start,instead of the end, of the existing trailers.

If it isafter, then each new trailer will appear just after thelast trailer with the same <key>.

If it isbefore, then each new trailer will appear just before thefirst trailer with the same <key>.

trailer.ifexists

This option makes it possible to choose what action will beperformed when there is already at least one trailer with thesame <key> in the input.

The valid values for this option are:addIfDifferentNeighbor (thisis the default),addIfDifferent,add,replace ordoNothing.

WithaddIfDifferentNeighbor, a new trailer will be added only if notrailer with the same (<key>, <value>) pair is above or below the linewhere the new trailer will be added.

WithaddIfDifferent, a new trailer will be added only if no trailerwith the same (<key>, <value>) pair is already in the input.

Withadd, a new trailer will be added, even if some trailers withthe same (<key>, <value>) pair are already in the input.

Withreplace, an existing trailer with the same <key> will bedeleted and the new trailer will be added. The deleted trailer will bethe closest one (with the same <key>) to the place where the new onewill be added.

WithdoNothing, nothing will be done; that is no new trailer will beadded if there is already one with the same <key> in the input.

trailer.ifmissing

This option makes it possible to choose what action will beperformed when there is not yet any trailer with the same<key> in the input.

The valid values for this option are:add (this is the default) anddoNothing.

Withadd, a new trailer will be added.

WithdoNothing, nothing will be done.

trailer.<keyAlias>.key

Defines a <keyAlias> for the <key>. The <keyAlias> must be aprefix (case does not matter) of the <key>. For example, ingitconfigtrailer.ack.key "Acked-by" the "Acked-by" is the <key> andthe "ack" is the <keyAlias>. This configuration allows the shorter--trailer "ack:..." invocation on the command line using the "ack"<keyAlias> instead of the longer--trailer "Acked-by:...".

At the end of the <key>, a separator can appear and then somespace characters. By default the only valid separator is:,but this can be changed using thetrailer.separators configvariable.

If there is a separator in the key, then it overrides the defaultseparator when adding the trailer.

trailer.<keyAlias>.where

This option takes the same values as thetrailer.whereconfiguration variable and it overrides what is specified bythat option for trailers with the specified <keyAlias>.

trailer.<keyAlias>.ifexists

This option takes the same values as thetrailer.ifexistsconfiguration variable and it overrides what is specified bythat option for trailers with the specified <keyAlias>.

trailer.<keyAlias>.ifmissing

This option takes the same values as thetrailer.ifmissingconfiguration variable and it overrides what is specified bythat option for trailers with the specified <keyAlias>.

trailer.<keyAlias>.command

Deprecated in favor oftrailer.<keyAlias>.cmd.This option behaves in the same way astrailer.<keyAlias>.cmd, exceptthat it doesn’t pass anything as argument to the specified command.Instead the first occurrence of substring $ARG is replaced by the<value> that would be passed as argument.

Note that $ARG in the user’s command isonly replaced once and that the original way of replacing $ARG is not safe.

When bothtrailer.<keyAlias>.cmd andtrailer.<keyAlias>.command are givenfor the same <keyAlias>,trailer.<keyAlias>.cmd is used andtrailer.<keyAlias>.command is ignored.

trailer.<keyAlias>.cmd

This option can be used to specify a shell command that will be calledonce to automatically add a trailer with the specified <keyAlias>, and thencalled each time a--trailer <keyAlias>=<value> argument is specified tomodify the <value> of the trailer that this option would produce.

When the specified command is first called to add a trailerwith the specified <keyAlias>, the behavior is as if a special--trailer <keyAlias>=<value> argument was added at the beginningof the "git interpret-trailers" command, where <value>is taken to be the standard output of the command with anyleading and trailing whitespace trimmed off.

If some--trailer <keyAlias>=<value> arguments are also passedon the command line, the command is called again once for eachof these arguments with the same <keyAlias>. And the <value> partof these arguments, if any, will be passed to the command as itsfirst argument. This way the command can produce a <value> computedfrom the <value> passed in the--trailer <keyAlias>=<value> argument.

transfer.credentialsInUrl

A configured URL can contain plaintext credentials in the form<protocol>://<user>:<password>@<domain>/<path>. You may wantto warn or forbid the use of such configuration (in favor ofusinggit-credential(1)). This will be used ongit-clone(1),git-fetch(1),git-push(1),and any other direct use of the configured URL.

Note that this is currently limited to detecting credentials inremote.<name>.url configuration; it won’t detect credentials inremote.<name>.pushurl configuration.

You might want to enable this to prevent inadvertent credentialsexposure, e.g. because:

• The OS or system where you’re running git may not provide a way orotherwise allow you to configure the permissions of theconfiguration file where the username and/or password are stored.

• Even if it does, having such data stored "at rest" might expose youin other ways, e.g. a backup process might copy the data to anothersystem.

• The git programs will pass the full URL to one another as argumentson the command-line, meaning the credentials will be exposed to otherunprivileged users on systems that allow them to see the fullprocess list of other users. On linux the "hidepid" settingdocumented in procfs(5) allows for configuring this behavior.

  If such concerns don’t apply to you then you probably don’t need to beconcerned about credentials exposure due to storing sensitivedata in git’s configuration files. If you do want to use this, settransfer.credentialsInUrl to one of these values:

• allow (default): Git will proceed with its activity without warning.

• warn: Git will write a warning message tostderr when parsing a URLwith a plaintext credential.

• die: Git will write a failure message tostderr when parsing a URLwith a plaintext credential.

transfer.fsckObjects

Whenfetch.fsckObjects orreceive.fsckObjects arenot set, the value of this variable is used instead.Defaults to false.

When set, the fetch or receive will abort in the case of a malformedobject or a link to a nonexistent object. In addition, various otherissues are checked for, including legacy issues (seefsck.<msg-id>),and potential security issues like the existence of a .GIT directoryor a malicious .gitmodules file (see the release notes for v2.2.1and v2.17.1 for details). Other sanity and security checks may beadded in future releases.

On the receiving side, failing fsckObjects will make those objectsunreachable, see "QUARANTINE ENVIRONMENT" ingit-receive-pack(1). On the fetch side, malformed objects willinstead be left unreferenced in the repository.

Due to the non-quarantine nature of thefetch.fsckObjectsimplementation it cannot be relied upon to leave the object storeclean likereceive.fsckObjects can.

As objects are unpacked they’re written to the object store, so therecan be cases where malicious objects get introduced even though the"fetch" failed, only to have a subsequent "fetch" succeed because onlynew incoming objects are checked, not those that have already beenwritten to the object store. That difference in behavior should not berelied upon. In the future, such objects may be quarantined for"fetch" as well.

For now, the paranoid need to find some way to emulate the quarantineenvironment if they’d like the same protection as "push". E.g. in thecase of an internal mirror do the mirroring in two steps, one to fetchthe untrusted objects, and then do a second "push" (which will use thequarantine) to another internal repo, and have internal clientsconsume this pushed-to repository, or embargo internal fetches andonly allow them once a full "fsck" has run (and no new fetches havehappened in the meantime).

transfer.hideRefs

String(s)receive-pack andupload-pack use to decide whichrefs to omit from their initial advertisements. Use more thanone definition to specify multiple prefix strings. A ref that isunder the hierarchies listed in the value of this variable isexcluded, and is hidden when responding togitpush orgitfetch. Seereceive.hideRefs anduploadpack.hideRefs forprogram-specific versions of this config.

You may also include a ! in front of the ref name to negate the entry,explicitly exposing it, even if an earlier entry marked it as hidden.If you have multiple hideRefs values, later entries override earlier ones(and entries in more-specific config files override less-specific ones).

If a namespace is in use, the namespace prefix is stripped from eachreference before it is matched againsttransfer.hiderefs patterns. Inorder to match refs before stripping, add a^ in front of the ref name. Ifyou combine ! and^, ! must be specified first.

For example, ifrefs/heads/master is specified intransfer.hideRefs andthe current namespace isfoo, thenrefs/namespaces/foo/refs/heads/masteris omitted from the advertisements. Ifuploadpack.allowRefInWant is set,upload-pack will treatwant-refrefs/heads/master in a protocol v2fetch command as ifrefs/namespaces/foo/refs/heads/master did not exist.receive-pack, on the other hand, will still advertise the object id theref is pointing to without mentioning its name (a so-called ".have" line).

Even if you hide refs, a client may still be able to steal the targetobjects via the techniques described in the "SECURITY" section of thegitnamespaces(7) man page; it’s best to keep private data in aseparate repository.

transfer.unpackLimit

Whenfetch.unpackLimit orreceive.unpackLimit arenot set, the value of this variable is used instead.The default value is 100.

transfer.advertiseSID

Boolean. When true, client and server processes will advertise theirunique session IDs to their remote counterpart. Defaults to false.

transfer.bundleURI

Whentrue, localgitclone commands will request bundleinformation from the remote server (if advertised) and downloadbundles before continuing the clone through the Git protocol.Defaults tofalse.

transfer.advertiseObjectInfo

Whentrue, theobject-info capability is advertised byservers. Defaults to false.

uploadarchive.allowUnreachable

If true, allow clients to usegitarchive--remote to requestany tree, whether reachable from the ref tips or not. See thediscussion in the "SECURITY" section ofgit-upload-archive(1) for more details. Defaults tofalse.

uploadpack.hideRefs

This variable is the same astransfer.hideRefs, but appliesonly toupload-pack (and so affects only fetches, not pushes).An attempt to fetch a hidden ref bygitfetch will fail. Seealsouploadpack.allowTipSHA1InWant.

uploadpack.allowTipSHA1InWant

Whenuploadpack.hideRefs is in effect, allowupload-packto accept a fetch request that asks for an object at the tipof a hidden ref (by default, such a request is rejected).See alsouploadpack.hideRefs. Even if this is false, a clientmay be able to steal objects via the techniques described in the"SECURITY" section of thegitnamespaces(7) man page; it’sbest to keep private data in a separate repository.

uploadpack.allowReachableSHA1InWant

Allowupload-pack to accept a fetch request that asks for anobject that is reachable from any ref tip. However, note thatcalculating object reachability is computationally expensive.Defaults tofalse. Even if this is false, a client may be ableto steal objects via the techniques described in the "SECURITY"section of thegitnamespaces(7) man page; it’s best tokeep private data in a separate repository.

uploadpack.allowAnySHA1InWant

Allowupload-pack to accept a fetch request that asks for anyobject at all.It impliesuploadpack.allowTipSHA1InWant anduploadpack.allowReachableSHA1InWant. If set totrue it willenable both of them, it set tofalse it will disable both ofthem.By default not set.

uploadpack.keepAlive

Whenupload-pack has startedpack-objects, there may be aquiet period whilepack-objects prepares the pack. Normallyit would output progress information, but if--quiet was usedfor the fetch,pack-objects will output nothing at all untilthe pack data begins. Some clients and networks may considerthe server to be hung and give up. Setting this option instructsupload-pack to send an empty keepalive packet everyuploadpack.keepAlive seconds. Setting this option to 0disables keepalive packets entirely. The default is 5 seconds.

uploadpack.packObjectsHook

If this option is set, whenupload-pack would rungitpack-objects to create a packfile for a client, it willrun this shell command instead. Thepack-objects command andarguments itwould have run (including thegitpack-objectsat the beginning) are appended to the shell command. The stdinand stdout of the hook are treated as ifpack-objects itselfwas run. I.e.,upload-pack will feed input intended forpack-objects to the hook, and expects a completed packfile onstdout.

Note that this configuration variable is only respected when it is specifiedin protected configuration (seeSCOPES). This is a safety measureagainst fetching from untrusted repositories.

uploadpack.allowFilter

If this option is set,upload-pack will support partialclone and partial fetch object filtering.

uploadpackfilter.allow

Provides a default value for unspecified object filters (see: thebelow configuration variable). If set totrue, this will alsoenable all filters which get added in the future.Defaults totrue.

uploadpackfilter.<filter>.allow

Explicitly allow or ban the object filter corresponding to<filter>, where<filter> may be one of:blob:none,blob:limit,object:type,tree,sparse:oid, orcombine.If using combined filters, bothcombine and all of the nestedfilter kinds must be allowed. Defaults touploadpackfilter.allow.

uploadpackfilter.tree.maxDepth

Only allow--filter=tree:<n> when<n> is no more than the value ofuploadpackfilter.tree.maxDepth. If set, this also impliesuploadpackfilter.tree.allow=true, unless this configurationvariable had already been set. Has no effect if unset.

uploadpack.allowRefInWant

If this option is set,upload-pack will support theref-in-wantfeature of the protocol version 2fetch command. This featureis intended for the benefit of load-balanced servers which maynot have the same view of what OIDs their refs point to due toreplication delay.

url.<base>.insteadOf

Any URL that starts with this value will be rewritten tostart, instead, with <base>. In cases where some site serves alarge number of repositories, and serves them with multipleaccess methods, and some users need to use different accessmethods, this feature allows people to specify any of theequivalent URLs and have Git automatically rewrite the URL tothe best alternative for the particular user, even for anever-before-seen repository on the site. When more than oneinsteadOf strings match a given URL, the longest match is used.

Note that any protocol restrictions will be applied to the rewrittenURL. If the rewrite changes the URL to use a custom protocol or remotehelper, you may need to adjust theprotocol.*.allow config to permitthe request. In particular, protocols you expect to use for submodulesmust be set toalways rather than the default ofuser. See thedescription ofprotocol.allow above.

url.<base>.pushInsteadOf

Any URL that starts with this value will not be pushed to;instead, it will be rewritten to start with <base>, and theresulting URL will be pushed to. In cases where some site servesa large number of repositories, and serves them with multipleaccess methods, some of which do not allow push, this featureallows people to specify a pull-only URL and have Gitautomatically use an appropriate URL to push, even for anever-before-seen repository on the site. When more than onepushInsteadOf strings match a given URL, the longest match isused. If a remote has an explicit pushurl, Git will ignore thissetting for that remote.

user.name

user.email

author.name

author.email

committer.name

committer.email

Theuser.name anduser.email variables determine what endsup in theauthor andcommitter fields of commitobjects.If you need theauthor orcommitter to be different, theauthor.name,author.email,committer.name, orcommitter.email variables can be set.All of these can be overridden by theGIT_AUTHOR_NAME,GIT_AUTHOR_EMAIL,GIT_COMMITTER_NAME,GIT_COMMITTER_EMAIL, andEMAIL environment variables.

Note that thename forms of these variables conventionally refer tosome form of a personal name. Seegit-commit(1) and theenvironment variables section ofgit(1) for more information onthese settings and thecredential.username option if you’re lookingfor authentication credentials instead.

user.useConfigOnly

Instruct Git to avoid trying to guess defaults foruser.emailanduser.name, and instead retrieve the values only from theconfiguration. For example, if you have multiple email addressesand would like to use a different one for each repository, thenwith this configuration option set totrue in the global configalong with a name, Git will prompt you to set up an email beforemaking new commits in a newly cloned repository.Defaults tofalse.

user.signingKey

Ifgit-tag(1) orgit-commit(1) is not selecting thekey you want it to automatically when creating a signed tag orcommit, you can override the default selection with this variable.This option is passed unchanged to gpg’s --local-user parameter,so you may specify a key using any method that gpg supports.If gpg.format is set tossh this can contain the path to eitheryour private ssh key or the public key when ssh-agent is used.Alternatively it can contain a public key prefixed withkey::directly (e.g.: "key::ssh-rsa XXXXXX identifier"). The private keyneeds to be available via ssh-agent. If not set Git will callgpg.ssh.defaultKeyCommand (e.g.: "ssh-add -L") and try to use thefirst key available. For backward compatibility, a raw key whichbegins with "ssh-", such as "ssh-rsa XXXXXX identifier", is treatedas "key::ssh-rsa XXXXXX identifier", but this form is deprecated;use thekey:: form instead.

versionsort.prereleaseSuffix (deprecated)

Deprecated alias forversionsort.suffix. Ignored ifversionsort.suffix is set.

versionsort.suffix

Even when version sort is used ingit-tag(1), tagnameswith the same base version but different suffixes are still sortedlexicographically, resulting e.g. in prerelease tags appearingafter the main release (e.g. "1.0-rc1" after "1.0"). Thisvariable can be specified to determine the sorting order of tagswith different suffixes.

By specifying a single suffix in this variable, any tagname containingthat suffix will appear before the corresponding main release. E.g. ifthe variable is set to "-rc", then all "1.0-rcX" tags will appear before"1.0". If specified multiple times, once per suffix, then the order ofsuffixes in the configuration will determine the sorting order of tagnameswith those suffixes. E.g. if "-pre" appears before "-rc" in theconfiguration, then all "1.0-preX" tags will be listed before any"1.0-rcX" tags. The placement of the main release tag relative to tagswith various suffixes can be determined by specifying the empty suffixamong those other suffixes. E.g. if the suffixes "-rc", "", "-ck", and"-bfs" appear in the configuration in this order, then all "v4.8-rcX" tagsare listed first, followed by "v4.8", then "v4.8-ckX" and finally"v4.8-bfsX".

If more than one suffix matches the same tagname, then that tagname willbe sorted according to the suffix which starts at the earliest position inthe tagname. If more than one different matching suffix starts atthat earliest position, then that tagname will be sorted according to thelongest of those suffixes.The sorting order between different suffixes is undefined if they arein multiple config files.

web.browser

Specify a web browser that may be used by some commands.Currently onlygit-instaweb(1) andgit-help(1)may use it.

worktree.guessRemote

If no branch is specified and neither-b nor-B nor--detach is used, thengitworktreeadd defaults tocreating a new branch from HEAD. Ifworktree.guessRemote isset to true,worktreeadd tries to find a remote-trackingbranch whose name uniquely matches the new branch name. Ifsuch a branch exists, it is checked out and set as "upstream"for the new branch. If no such match can be found, it fallsback to creating a new branch from the currentHEAD.

worktree.useRelativePaths

Link worktrees using relative paths (when "true") or absolutepaths (when "false"). This is particularly useful for setupswhere the repository and worktrees may be moved betweendifferent locations or environments. Defaults to "false".

Note that settingworktree.useRelativePaths to "true" implies enabling theextensions.relativeWorktrees config (seegit-config(1)),thus making it incompatible with older versions of Git.

  [section.subsection]    key = value1

  [section.subsection]    key = value1    key = value2