Merge branch 'js/mingw-perl5lib'
[git/git.git] / Documentation / config / core.txt
1 core.fileMode::
2 Tells Git if the executable bit of files in the working tree
3 is to be honored.
4 +
5 Some filesystems lose the executable bit when a file that is
6 marked as executable is checked out, or checks out a
7 non-executable file with executable bit on.
8 linkgit:git-clone[1] or linkgit:git-init[1] probe the filesystem
9 to see if it handles the executable bit correctly
10 and this variable is automatically set as necessary.
11 +
12 A repository, however, may be on a filesystem that handles
13 the filemode correctly, and this variable is set to 'true'
14 when created, but later may be made accessible from another
15 environment that loses the filemode (e.g. exporting ext4 via
16 CIFS mount, visiting a Cygwin created repository with
17 Git for Windows or Eclipse).
18 In such a case it may be necessary to set this variable to 'false'.
19 See linkgit:git-update-index[1].
20 +
21 The default is true (when core.filemode is not specified in the config file).
22
23 core.hideDotFiles::
24 (Windows-only) If true, mark newly-created directories and files whose
25 name starts with a dot as hidden. If 'dotGitOnly', only the `.git/`
26 directory is hidden, but no other files starting with a dot. The
27 default mode is 'dotGitOnly'.
28
29 core.ignoreCase::
30 Internal variable which enables various workarounds to enable
31 Git to work better on filesystems that are not case sensitive,
32 like APFS, HFS+, FAT, NTFS, etc. For example, if a directory listing
33 finds "makefile" when Git expects "Makefile", Git will assume
34 it is really the same file, and continue to remember it as
35 "Makefile".
36 +
37 The default is false, except linkgit:git-clone[1] or linkgit:git-init[1]
38 will probe and set core.ignoreCase true if appropriate when the repository
39 is created.
40 +
41 Git relies on the proper configuration of this variable for your operating
42 and file system. Modifying this value may result in unexpected behavior.
43
44 core.precomposeUnicode::
45 This option is only used by Mac OS implementation of Git.
46 When core.precomposeUnicode=true, Git reverts the unicode decomposition
47 of filenames done by Mac OS. This is useful when sharing a repository
48 between Mac OS and Linux or Windows.
49 (Git for Windows 1.7.10 or higher is needed, or Git under cygwin 1.7).
50 When false, file names are handled fully transparent by Git,
51 which is backward compatible with older versions of Git.
52
53 core.protectHFS::
54 If set to true, do not allow checkout of paths that would
55 be considered equivalent to `.git` on an HFS+ filesystem.
56 Defaults to `true` on Mac OS, and `false` elsewhere.
57
58 core.protectNTFS::
59 If set to true, do not allow checkout of paths that would
60 cause problems with the NTFS filesystem, e.g. conflict with
61 8.3 "short" names.
62 Defaults to `true` on Windows, and `false` elsewhere.
63
64 core.fsmonitor::
65 If set, the value of this variable is used as a command which
66 will identify all files that may have changed since the
67 requested date/time. This information is used to speed up git by
68 avoiding unnecessary processing of files that have not changed.
69 See the "fsmonitor-watchman" section of linkgit:githooks[5].
70
71 core.trustctime::
72 If false, the ctime differences between the index and the
73 working tree are ignored; useful when the inode change time
74 is regularly modified by something outside Git (file system
75 crawlers and some backup systems).
76 See linkgit:git-update-index[1]. True by default.
77
78 core.splitIndex::
79 If true, the split-index feature of the index will be used.
80 See linkgit:git-update-index[1]. False by default.
81
82 core.untrackedCache::
83 Determines what to do about the untracked cache feature of the
84 index. It will be kept, if this variable is unset or set to
85 `keep`. It will automatically be added if set to `true`. And
86 it will automatically be removed, if set to `false`. Before
87 setting it to `true`, you should check that mtime is working
88 properly on your system.
89 See linkgit:git-update-index[1]. `keep` by default.
90
91 core.checkStat::
92 When missing or is set to `default`, many fields in the stat
93 structure are checked to detect if a file has been modified
94 since Git looked at it. When this configuration variable is
95 set to `minimal`, sub-second part of mtime and ctime, the
96 uid and gid of the owner of the file, the inode number (and
97 the device number, if Git was compiled to use it), are
98 excluded from the check among these fields, leaving only the
99 whole-second part of mtime (and ctime, if `core.trustCtime`
100 is set) and the filesize to be checked.
101 +
102 There are implementations of Git that do not leave usable values in
103 some fields (e.g. JGit); by excluding these fields from the
104 comparison, the `minimal` mode may help interoperability when the
105 same repository is used by these other systems at the same time.
106
107 core.quotePath::
108 Commands that output paths (e.g. 'ls-files', 'diff'), will
109 quote "unusual" characters in the pathname by enclosing the
110 pathname in double-quotes and escaping those characters with
111 backslashes in the same way C escapes control characters (e.g.
112 `\t` for TAB, `\n` for LF, `\\` for backslash) or bytes with
113 values larger than 0x80 (e.g. octal `\302\265` for "micro" in
114 UTF-8). If this variable is set to false, bytes higher than
115 0x80 are not considered "unusual" any more. Double-quotes,
116 backslash and control characters are always escaped regardless
117 of the setting of this variable. A simple space character is
118 not considered "unusual". Many commands can output pathnames
119 completely verbatim using the `-z` option. The default value
120 is true.
121
122 core.eol::
123 Sets the line ending type to use in the working directory for
124 files that have the `text` property set when core.autocrlf is false.
125 Alternatives are 'lf', 'crlf' and 'native', which uses the platform's
126 native line ending. The default value is `native`. See
127 linkgit:gitattributes[5] for more information on end-of-line
128 conversion.
129
130 core.safecrlf::
131 If true, makes Git check if converting `CRLF` is reversible when
132 end-of-line conversion is active. Git will verify if a command
133 modifies a file in the work tree either directly or indirectly.
134 For example, committing a file followed by checking out the
135 same file should yield the original file in the work tree. If
136 this is not the case for the current setting of
137 `core.autocrlf`, Git will reject the file. The variable can
138 be set to "warn", in which case Git will only warn about an
139 irreversible conversion but continue the operation.
140 +
141 CRLF conversion bears a slight chance of corrupting data.
142 When it is enabled, Git will convert CRLF to LF during commit and LF to
143 CRLF during checkout. A file that contains a mixture of LF and
144 CRLF before the commit cannot be recreated by Git. For text
145 files this is the right thing to do: it corrects line endings
146 such that we have only LF line endings in the repository.
147 But for binary files that are accidentally classified as text the
148 conversion can corrupt data.
149 +
150 If you recognize such corruption early you can easily fix it by
151 setting the conversion type explicitly in .gitattributes. Right
152 after committing you still have the original file in your work
153 tree and this file is not yet corrupted. You can explicitly tell
154 Git that this file is binary and Git will handle the file
155 appropriately.
156 +
157 Unfortunately, the desired effect of cleaning up text files with
158 mixed line endings and the undesired effect of corrupting binary
159 files cannot be distinguished. In both cases CRLFs are removed
160 in an irreversible way. For text files this is the right thing
161 to do because CRLFs are line endings, while for binary files
162 converting CRLFs corrupts data.
163 +
164 Note, this safety check does not mean that a checkout will generate a
165 file identical to the original file for a different setting of
166 `core.eol` and `core.autocrlf`, but only for the current one. For
167 example, a text file with `LF` would be accepted with `core.eol=lf`
168 and could later be checked out with `core.eol=crlf`, in which case the
169 resulting file would contain `CRLF`, although the original file
170 contained `LF`. However, in both work trees the line endings would be
171 consistent, that is either all `LF` or all `CRLF`, but never mixed. A
172 file with mixed line endings would be reported by the `core.safecrlf`
173 mechanism.
174
175 core.autocrlf::
176 Setting this variable to "true" is the same as setting
177 the `text` attribute to "auto" on all files and core.eol to "crlf".
178 Set to true if you want to have `CRLF` line endings in your
179 working directory and the repository has LF line endings.
180 This variable can be set to 'input',
181 in which case no output conversion is performed.
182
183 core.checkRoundtripEncoding::
184 A comma and/or whitespace separated list of encodings that Git
185 performs UTF-8 round trip checks on if they are used in an
186 `working-tree-encoding` attribute (see linkgit:gitattributes[5]).
187 The default value is `SHIFT-JIS`.
188
189 core.symlinks::
190 If false, symbolic links are checked out as small plain files that
191 contain the link text. linkgit:git-update-index[1] and
192 linkgit:git-add[1] will not change the recorded type to regular
193 file. Useful on filesystems like FAT that do not support
194 symbolic links.
195 +
196 The default is true, except linkgit:git-clone[1] or linkgit:git-init[1]
197 will probe and set core.symlinks false if appropriate when the repository
198 is created.
199
200 core.gitProxy::
201 A "proxy command" to execute (as 'command host port') instead
202 of establishing direct connection to the remote server when
203 using the Git protocol for fetching. If the variable value is
204 in the "COMMAND for DOMAIN" format, the command is applied only
205 on hostnames ending with the specified domain string. This variable
206 may be set multiple times and is matched in the given order;
207 the first match wins.
208 +
209 Can be overridden by the `GIT_PROXY_COMMAND` environment variable
210 (which always applies universally, without the special "for"
211 handling).
212 +
213 The special string `none` can be used as the proxy command to
214 specify that no proxy be used for a given domain pattern.
215 This is useful for excluding servers inside a firewall from
216 proxy use, while defaulting to a common proxy for external domains.
217
218 core.sshCommand::
219 If this variable is set, `git fetch` and `git push` will
220 use the specified command instead of `ssh` when they need to
221 connect to a remote system. The command is in the same form as
222 the `GIT_SSH_COMMAND` environment variable and is overridden
223 when the environment variable is set.
224
225 core.ignoreStat::
226 If true, Git will avoid using lstat() calls to detect if files have
227 changed by setting the "assume-unchanged" bit for those tracked files
228 which it has updated identically in both the index and working tree.
229 +
230 When files are modified outside of Git, the user will need to stage
231 the modified files explicitly (e.g. see 'Examples' section in
232 linkgit:git-update-index[1]).
233 Git will not normally detect changes to those files.
234 +
235 This is useful on systems where lstat() calls are very slow, such as
236 CIFS/Microsoft Windows.
237 +
238 False by default.
239
240 core.preferSymlinkRefs::
241 Instead of the default "symref" format for HEAD
242 and other symbolic reference files, use symbolic links.
243 This is sometimes needed to work with old scripts that
244 expect HEAD to be a symbolic link.
245
246 core.alternateRefsCommand::
247 When advertising tips of available history from an alternate, use the shell to
248 execute the specified command instead of linkgit:git-for-each-ref[1]. The
249 first argument is the absolute path of the alternate. Output must contain one
250 hex object id per line (i.e., the same as produced by `git for-each-ref
251 --format='%(objectname)'`).
252 +
253 Note that you cannot generally put `git for-each-ref` directly into the config
254 value, as it does not take a repository path as an argument (but you can wrap
255 the command above in a shell script).
256
257 core.alternateRefsPrefixes::
258 When listing references from an alternate, list only references that begin
259 with the given prefix. Prefixes match as if they were given as arguments to
260 linkgit:git-for-each-ref[1]. To list multiple prefixes, separate them with
261 whitespace. If `core.alternateRefsCommand` is set, setting
262 `core.alternateRefsPrefixes` has no effect.
263
264 core.bare::
265 If true this repository is assumed to be 'bare' and has no
266 working directory associated with it. If this is the case a
267 number of commands that require a working directory will be
268 disabled, such as linkgit:git-add[1] or linkgit:git-merge[1].
269 +
270 This setting is automatically guessed by linkgit:git-clone[1] or
271 linkgit:git-init[1] when the repository was created. By default a
272 repository that ends in "/.git" is assumed to be not bare (bare =
273 false), while all other repositories are assumed to be bare (bare
274 = true).
275
276 core.worktree::
277 Set the path to the root of the working tree.
278 If `GIT_COMMON_DIR` environment variable is set, core.worktree
279 is ignored and not used for determining the root of working tree.
280 This can be overridden by the `GIT_WORK_TREE` environment
281 variable and the `--work-tree` command-line option.
282 The value can be an absolute path or relative to the path to
283 the .git directory, which is either specified by --git-dir
284 or GIT_DIR, or automatically discovered.
285 If --git-dir or GIT_DIR is specified but none of
286 --work-tree, GIT_WORK_TREE and core.worktree is specified,
287 the current working directory is regarded as the top level
288 of your working tree.
289 +
290 Note that this variable is honored even when set in a configuration
291 file in a ".git" subdirectory of a directory and its value differs
292 from the latter directory (e.g. "/path/to/.git/config" has
293 core.worktree set to "/different/path"), which is most likely a
294 misconfiguration. Running Git commands in the "/path/to" directory will
295 still use "/different/path" as the root of the work tree and can cause
296 confusion unless you know what you are doing (e.g. you are creating a
297 read-only snapshot of the same index to a location different from the
298 repository's usual working tree).
299
300 core.logAllRefUpdates::
301 Enable the reflog. Updates to a ref <ref> is logged to the file
302 "`$GIT_DIR/logs/<ref>`", by appending the new and old
303 SHA-1, the date/time and the reason of the update, but
304 only when the file exists. If this configuration
305 variable is set to `true`, missing "`$GIT_DIR/logs/<ref>`"
306 file is automatically created for branch heads (i.e. under
307 `refs/heads/`), remote refs (i.e. under `refs/remotes/`),
308 note refs (i.e. under `refs/notes/`), and the symbolic ref `HEAD`.
309 If it is set to `always`, then a missing reflog is automatically
310 created for any ref under `refs/`.
311 +
312 This information can be used to determine what commit
313 was the tip of a branch "2 days ago".
314 +
315 This value is true by default in a repository that has
316 a working directory associated with it, and false by
317 default in a bare repository.
318
319 core.repositoryFormatVersion::
320 Internal variable identifying the repository format and layout
321 version.
322
323 core.sharedRepository::
324 When 'group' (or 'true'), the repository is made shareable between
325 several users in a group (making sure all the files and objects are
326 group-writable). When 'all' (or 'world' or 'everybody'), the
327 repository will be readable by all users, additionally to being
328 group-shareable. When 'umask' (or 'false'), Git will use permissions
329 reported by umask(2). When '0xxx', where '0xxx' is an octal number,
330 files in the repository will have this mode value. '0xxx' will override
331 user's umask value (whereas the other options will only override
332 requested parts of the user's umask value). Examples: '0660' will make
333 the repo read/write-able for the owner and group, but inaccessible to
334 others (equivalent to 'group' unless umask is e.g. '0022'). '0640' is a
335 repository that is group-readable but not group-writable.
336 See linkgit:git-init[1]. False by default.
337
338 core.warnAmbiguousRefs::
339 If true, Git will warn you if the ref name you passed it is ambiguous
340 and might match multiple refs in the repository. True by default.
341
342 core.compression::
343 An integer -1..9, indicating a default compression level.
344 -1 is the zlib default. 0 means no compression,
345 and 1..9 are various speed/size tradeoffs, 9 being slowest.
346 If set, this provides a default to other compression variables,
347 such as `core.looseCompression` and `pack.compression`.
348
349 core.looseCompression::
350 An integer -1..9, indicating the compression level for objects that
351 are not in a pack file. -1 is the zlib default. 0 means no
352 compression, and 1..9 are various speed/size tradeoffs, 9 being
353 slowest. If not set, defaults to core.compression. If that is
354 not set, defaults to 1 (best speed).
355
356 core.packedGitWindowSize::
357 Number of bytes of a pack file to map into memory in a
358 single mapping operation. Larger window sizes may allow
359 your system to process a smaller number of large pack files
360 more quickly. Smaller window sizes will negatively affect
361 performance due to increased calls to the operating system's
362 memory manager, but may improve performance when accessing
363 a large number of large pack files.
364 +
365 Default is 1 MiB if NO_MMAP was set at compile time, otherwise 32
366 MiB on 32 bit platforms and 1 GiB on 64 bit platforms. This should
367 be reasonable for all users/operating systems. You probably do
368 not need to adjust this value.
369 +
370 Common unit suffixes of 'k', 'm', or 'g' are supported.
371
372 core.packedGitLimit::
373 Maximum number of bytes to map simultaneously into memory
374 from pack files. If Git needs to access more than this many
375 bytes at once to complete an operation it will unmap existing
376 regions to reclaim virtual address space within the process.
377 +
378 Default is 256 MiB on 32 bit platforms and 32 TiB (effectively
379 unlimited) on 64 bit platforms.
380 This should be reasonable for all users/operating systems, except on
381 the largest projects. You probably do not need to adjust this value.
382 +
383 Common unit suffixes of 'k', 'm', or 'g' are supported.
384
385 core.deltaBaseCacheLimit::
386 Maximum number of bytes to reserve for caching base objects
387 that may be referenced by multiple deltified objects. By storing the
388 entire decompressed base objects in a cache Git is able
389 to avoid unpacking and decompressing frequently used base
390 objects multiple times.
391 +
392 Default is 96 MiB on all platforms. This should be reasonable
393 for all users/operating systems, except on the largest projects.
394 You probably do not need to adjust this value.
395 +
396 Common unit suffixes of 'k', 'm', or 'g' are supported.
397
398 core.bigFileThreshold::
399 Files larger than this size are stored deflated, without
400 attempting delta compression. Storing large files without
401 delta compression avoids excessive memory usage, at the
402 slight expense of increased disk usage. Additionally files
403 larger than this size are always treated as binary.
404 +
405 Default is 512 MiB on all platforms. This should be reasonable
406 for most projects as source code and other text files can still
407 be delta compressed, but larger binary media files won't be.
408 +
409 Common unit suffixes of 'k', 'm', or 'g' are supported.
410
411 core.excludesFile::
412 Specifies the pathname to the file that contains patterns to
413 describe paths that are not meant to be tracked, in addition
414 to '.gitignore' (per-directory) and '.git/info/exclude'.
415 Defaults to `$XDG_CONFIG_HOME/git/ignore`.
416 If `$XDG_CONFIG_HOME` is either not set or empty, `$HOME/.config/git/ignore`
417 is used instead. See linkgit:gitignore[5].
418
419 core.askPass::
420 Some commands (e.g. svn and http interfaces) that interactively
421 ask for a password can be told to use an external program given
422 via the value of this variable. Can be overridden by the `GIT_ASKPASS`
423 environment variable. If not set, fall back to the value of the
424 `SSH_ASKPASS` environment variable or, failing that, a simple password
425 prompt. The external program shall be given a suitable prompt as
426 command-line argument and write the password on its STDOUT.
427
428 core.attributesFile::
429 In addition to '.gitattributes' (per-directory) and
430 '.git/info/attributes', Git looks into this file for attributes
431 (see linkgit:gitattributes[5]). Path expansions are made the same
432 way as for `core.excludesFile`. Its default value is
433 `$XDG_CONFIG_HOME/git/attributes`. If `$XDG_CONFIG_HOME` is either not
434 set or empty, `$HOME/.config/git/attributes` is used instead.
435
436 core.hooksPath::
437 By default Git will look for your hooks in the
438 '$GIT_DIR/hooks' directory. Set this to different path,
439 e.g. '/etc/git/hooks', and Git will try to find your hooks in
440 that directory, e.g. '/etc/git/hooks/pre-receive' instead of
441 in '$GIT_DIR/hooks/pre-receive'.
442 +
443 The path can be either absolute or relative. A relative path is
444 taken as relative to the directory where the hooks are run (see
445 the "DESCRIPTION" section of linkgit:githooks[5]).
446 +
447 This configuration variable is useful in cases where you'd like to
448 centrally configure your Git hooks instead of configuring them on a
449 per-repository basis, or as a more flexible and centralized
450 alternative to having an `init.templateDir` where you've changed
451 default hooks.
452
453 core.editor::
454 Commands such as `commit` and `tag` that let you edit
455 messages by launching an editor use the value of this
456 variable when it is set, and the environment variable
457 `GIT_EDITOR` is not set. See linkgit:git-var[1].
458
459 core.commentChar::
460 Commands such as `commit` and `tag` that let you edit
461 messages consider a line that begins with this character
462 commented, and removes them after the editor returns
463 (default '#').
464 +
465 If set to "auto", `git-commit` would select a character that is not
466 the beginning character of any line in existing commit messages.
467
468 core.filesRefLockTimeout::
469 The length of time, in milliseconds, to retry when trying to
470 lock an individual reference. Value 0 means not to retry at
471 all; -1 means to try indefinitely. Default is 100 (i.e.,
472 retry for 100ms).
473
474 core.packedRefsTimeout::
475 The length of time, in milliseconds, to retry when trying to
476 lock the `packed-refs` file. Value 0 means not to retry at
477 all; -1 means to try indefinitely. Default is 1000 (i.e.,
478 retry for 1 second).
479
480 core.pager::
481 Text viewer for use by Git commands (e.g., 'less'). The value
482 is meant to be interpreted by the shell. The order of preference
483 is the `$GIT_PAGER` environment variable, then `core.pager`
484 configuration, then `$PAGER`, and then the default chosen at
485 compile time (usually 'less').
486 +
487 When the `LESS` environment variable is unset, Git sets it to `FRX`
488 (if `LESS` environment variable is set, Git does not change it at
489 all). If you want to selectively override Git's default setting
490 for `LESS`, you can set `core.pager` to e.g. `less -S`. This will
491 be passed to the shell by Git, which will translate the final
492 command to `LESS=FRX less -S`. The environment does not set the
493 `S` option but the command line does, instructing less to truncate
494 long lines. Similarly, setting `core.pager` to `less -+F` will
495 deactivate the `F` option specified by the environment from the
496 command-line, deactivating the "quit if one screen" behavior of
497 `less`. One can specifically activate some flags for particular
498 commands: for example, setting `pager.blame` to `less -S` enables
499 line truncation only for `git blame`.
500 +
501 Likewise, when the `LV` environment variable is unset, Git sets it
502 to `-c`. You can override this setting by exporting `LV` with
503 another value or setting `core.pager` to `lv +c`.
504
505 core.whitespace::
506 A comma separated list of common whitespace problems to
507 notice. 'git diff' will use `color.diff.whitespace` to
508 highlight them, and 'git apply --whitespace=error' will
509 consider them as errors. You can prefix `-` to disable
510 any of them (e.g. `-trailing-space`):
511 +
512 * `blank-at-eol` treats trailing whitespaces at the end of the line
513 as an error (enabled by default).
514 * `space-before-tab` treats a space character that appears immediately
515 before a tab character in the initial indent part of the line as an
516 error (enabled by default).
517 * `indent-with-non-tab` treats a line that is indented with space
518 characters instead of the equivalent tabs as an error (not enabled by
519 default).
520 * `tab-in-indent` treats a tab character in the initial indent part of
521 the line as an error (not enabled by default).
522 * `blank-at-eof` treats blank lines added at the end of file as an error
523 (enabled by default).
524 * `trailing-space` is a short-hand to cover both `blank-at-eol` and
525 `blank-at-eof`.
526 * `cr-at-eol` treats a carriage-return at the end of line as
527 part of the line terminator, i.e. with it, `trailing-space`
528 does not trigger if the character before such a carriage-return
529 is not a whitespace (not enabled by default).
530 * `tabwidth=<n>` tells how many character positions a tab occupies; this
531 is relevant for `indent-with-non-tab` and when Git fixes `tab-in-indent`
532 errors. The default tab width is 8. Allowed values are 1 to 63.
533
534 core.fsyncObjectFiles::
535 This boolean will enable 'fsync()' when writing object files.
536 +
537 This is a total waste of time and effort on a filesystem that orders
538 data writes properly, but can be useful for filesystems that do not use
539 journalling (traditional UNIX filesystems) or that only journal metadata
540 and not file contents (OS X's HFS+, or Linux ext3 with "data=writeback").
541
542 core.preloadIndex::
543 Enable parallel index preload for operations like 'git diff'
544 +
545 This can speed up operations like 'git diff' and 'git status' especially
546 on filesystems like NFS that have weak caching semantics and thus
547 relatively high IO latencies. When enabled, Git will do the
548 index comparison to the filesystem data in parallel, allowing
549 overlapping IO's. Defaults to true.
550
551 core.unsetenvvars::
552 Windows-only: comma-separated list of environment variables'
553 names that need to be unset before spawning any other process.
554 Defaults to `PERL5LIB` to account for the fact that Git for
555 Windows insists on using its own Perl interpreter.
556
557 core.createObject::
558 You can set this to 'link', in which case a hardlink followed by
559 a delete of the source are used to make sure that object creation
560 will not overwrite existing objects.
561 +
562 On some file system/operating system combinations, this is unreliable.
563 Set this config setting to 'rename' there; However, This will remove the
564 check that makes sure that existing object files will not get overwritten.
565
566 core.notesRef::
567 When showing commit messages, also show notes which are stored in
568 the given ref. The ref must be fully qualified. If the given
569 ref does not exist, it is not an error but means that no
570 notes should be printed.
571 +
572 This setting defaults to "refs/notes/commits", and it can be overridden by
573 the `GIT_NOTES_REF` environment variable. See linkgit:git-notes[1].
574
575 core.commitGraph::
576 If true, then git will read the commit-graph file (if it exists)
577 to parse the graph structure of commits. Defaults to false. See
578 linkgit:git-commit-graph[1] for more information.
579
580 core.useReplaceRefs::
581 If set to `false`, behave as if the `--no-replace-objects`
582 option was given on the command line. See linkgit:git[1] and
583 linkgit:git-replace[1] for more information.
584
585 core.multiPackIndex::
586 Use the multi-pack-index file to track multiple packfiles using a
587 single index. See link:technical/multi-pack-index.html[the
588 multi-pack-index design document].
589
590 core.sparseCheckout::
591 Enable "sparse checkout" feature. See section "Sparse checkout" in
592 linkgit:git-read-tree[1] for more information.
593
594 core.abbrev::
595 Set the length object names are abbreviated to. If
596 unspecified or set to "auto", an appropriate value is
597 computed based on the approximate number of packed objects
598 in your repository, which hopefully is enough for
599 abbreviated object names to stay unique for some time.
600 The minimum length is 4.