1GIT(1)                            Git Manual                            GIT(1)
2
3
4

NAME

6       git - the stupid content tracker
7

SYNOPSIS

9       git [--version] [--exec-path[=GIT_EXEC_PATH]] [--html-path]
10           [-p|--paginate|--no-pager] [--no-replace-objects]
11           [--bare] [--git-dir=GIT_DIR] [--work-tree=GIT_WORK_TREE]
12           [--help] COMMAND [ARGS]
13
14

DESCRIPTION

16       Git is a fast, scalable, distributed revision control system with an
17       unusually rich command set that provides both high-level operations and
18       full access to internals.
19
20       See gittutorial(7) to get started, then see Everyday Git[1] for a
21       useful minimum set of commands, and "man git-commandname" for
22       documentation of each command. CVS users may also want to read gitcvs-
23       migration(7). See the Git User’s Manual[2] for a more in-depth
24       introduction.
25
26       The COMMAND is either a name of a Git command (see below) or an alias
27       as defined in the configuration file (see git-config(1)).
28
29       Formatted and hyperlinked version of the latest git documentation can
30       be viewed at http://www.kernel.org/pub/software/scm/git/docs/.
31

OPTIONS

33       --version
34           Prints the git suite version that the git program came from.
35
36       --help
37           Prints the synopsis and a list of the most commonly used commands.
38           If the option --all or -a is given then all available commands are
39           printed. If a git command is named this option will bring up the
40           manual page for that command.
41
42           Other options are available to control how the manual page is
43           displayed. See git-help(1) for more information, because git --help
44           ...  is converted internally into git help ....
45
46       --exec-path
47           Path to wherever your core git programs are installed. This can
48           also be controlled by setting the GIT_EXEC_PATH environment
49           variable. If no path is given, git will print the current setting
50           and then exit.
51
52       --html-path
53           Print the path to wherever your git HTML documentation is installed
54           and exit.
55
56       -p, --paginate
57           Pipe all output into less (or if set, $PAGER) if standard output is
58           a terminal. This overrides the pager.<cmd> configuration options
59           (see the "Configuration Mechanism" section below).
60
61       --no-pager
62           Do not pipe git output into a pager.
63
64       --git-dir=<path>
65           Set the path to the repository. This can also be controlled by
66           setting the GIT_DIR environment variable. It can be an absolute
67           path or relative path to current working directory.
68
69       --work-tree=<path>
70           Set the path to the working tree. The value will not be used in
71           combination with repositories found automatically in a .git
72           directory (i.e. $GIT_DIR is not set). This can also be controlled
73           by setting the GIT_WORK_TREE environment variable and the
74           core.worktree configuration variable. It can be an absolute path or
75           relative path to the directory specified by --git-dir or GIT_DIR.
76           Note: If --git-dir or GIT_DIR are specified but none of
77           --work-tree, GIT_WORK_TREE and core.worktree is specified, the
78           current working directory is regarded as the top directory of your
79           working tree.
80
81       --bare
82           Treat the repository as a bare repository. If GIT_DIR environment
83           is not set, it is set to the current working directory.
84
85       --no-replace-objects
86           Do not use replacement refs to replace git objects. See git-
87           replace(1) for more information.
88

FURTHER DOCUMENTATION

90       See the references above to get started using git. The following is
91       probably more detail than necessary for a first-time user.
92
93       The git concepts chapter of the user-manual[3] and gitcore-tutorial(7)
94       both provide introductions to the underlying git architecture.
95
96       See gitworkflows(7) for an overview of recommended workflows.
97
98       See also the howto[4] documents for some useful examples.
99
100       The internals are documented in the GIT API documentation[5].
101

GIT COMMANDS

103       We divide git into high level ("porcelain") commands and low level
104       ("plumbing") commands.
105

HIGH-LEVEL COMMANDS (PORCELAIN)

107       We separate the porcelain commands into the main commands and some
108       ancillary user utilities.
109
110   Main porcelain commands
111       git-add(1)
112           Add file contents to the index.
113
114       git-am(1)
115           Apply a series of patches from a mailbox.
116
117       git-archive(1)
118           Create an archive of files from a named tree.
119
120       git-bisect(1)
121           Find by binary search the change that introduced a bug.
122
123       git-branch(1)
124           List, create, or delete branches.
125
126       git-bundle(1)
127           Move objects and refs by archive.
128
129       git-checkout(1)
130           Checkout a branch or paths to the working tree.
131
132       git-cherry-pick(1)
133           Apply the change introduced by an existing commit.
134
135       git-citool(1)
136           Graphical alternative to git-commit.
137
138       git-clean(1)
139           Remove untracked files from the working tree.
140
141       git-clone(1)
142           Clone a repository into a new directory.
143
144       git-commit(1)
145           Record changes to the repository.
146
147       git-describe(1)
148           Show the most recent tag that is reachable from a commit.
149
150       git-diff(1)
151           Show changes between commits, commit and working tree, etc.
152
153       git-fetch(1)
154           Download objects and refs from another repository.
155
156       git-format-patch(1)
157           Prepare patches for e-mail submission.
158
159       git-gc(1)
160           Cleanup unnecessary files and optimize the local repository.
161
162       git-grep(1)
163           Print lines matching a pattern.
164
165       git-gui(1)
166           A portable graphical interface to Git.
167
168       git-init(1)
169           Create an empty git repository or reinitialize an existing one.
170
171       git-log(1)
172           Show commit logs.
173
174       git-merge(1)
175           Join two or more development histories together.
176
177       git-mv(1)
178           Move or rename a file, a directory, or a symlink.
179
180       git-notes(1)
181           Add/inspect object notes.
182
183       git-pull(1)
184           Fetch from and merge with another repository or a local branch.
185
186       git-push(1)
187           Update remote refs along with associated objects.
188
189       git-rebase(1)
190           Forward-port local commits to the updated upstream head.
191
192       git-reset(1)
193           Reset current HEAD to the specified state.
194
195       git-revert(1)
196           Revert an existing commit.
197
198       git-rm(1)
199           Remove files from the working tree and from the index.
200
201       git-shortlog(1)
202           Summarize git log output.
203
204       git-show(1)
205           Show various types of objects.
206
207       git-stash(1)
208           Stash the changes in a dirty working directory away.
209
210       git-status(1)
211           Show the working tree status.
212
213       git-submodule(1)
214           Initialize, update or inspect submodules.
215
216       git-tag(1)
217           Create, list, delete or verify a tag object signed with GPG.
218
219       gitk(1)
220           The git repository browser.
221
222   Ancillary Commands
223       Manipulators:
224
225       git-config(1)
226           Get and set repository or global options.
227
228       git-fast-export(1)
229           Git data exporter.
230
231       git-fast-import(1)
232           Backend for fast Git data importers.
233
234       git-filter-branch(1)
235           Rewrite branches.
236
237       git-lost-found(1)
238           (deprecated) Recover lost refs that luckily have not yet been
239           pruned.
240
241       git-mergetool(1)
242           Run merge conflict resolution tools to resolve merge conflicts.
243
244       git-pack-refs(1)
245           Pack heads and tags for efficient repository access.
246
247       git-prune(1)
248           Prune all unreachable objects from the object database.
249
250       git-reflog(1)
251           Manage reflog information.
252
253       git-relink(1)
254           Hardlink common objects in local repositories.
255
256       git-remote(1)
257           manage set of tracked repositories.
258
259       git-repack(1)
260           Pack unpacked objects in a repository.
261
262       git-replace(1)
263           Create, list, delete refs to replace objects.
264
265       git-repo-config(1)
266           (deprecated) Get and set repository or global options.
267
268       Interrogators:
269
270       git-annotate(1)
271           Annotate file lines with commit information.
272
273       git-blame(1)
274           Show what revision and author last modified each line of a file.
275
276       git-cherry(1)
277           Find commits not merged upstream.
278
279       git-count-objects(1)
280           Count unpacked number of objects and their disk consumption.
281
282       git-difftool(1)
283           Show changes using common diff tools.
284
285       git-fsck(1)
286           Verifies the connectivity and validity of the objects in the
287           database.
288
289       git-get-tar-commit-id(1)
290           Extract commit ID from an archive created using git-archive.
291
292       git-help(1)
293           display help information about git.
294
295       git-instaweb(1)
296           Instantly browse your working repository in gitweb.
297
298       git-merge-tree(1)
299           Show three-way merge without touching index.
300
301       git-rerere(1)
302           Reuse recorded resolution of conflicted merges.
303
304       git-rev-parse(1)
305           Pick out and massage parameters.
306
307       git-show-branch(1)
308           Show branches and their commits.
309
310       git-verify-tag(1)
311           Check the GPG signature of tags.
312
313       git-whatchanged(1)
314           Show logs with difference each commit introduces.
315
316   Interacting with Others
317       These commands are to interact with foreign SCM and with other people
318       via patch over e-mail.
319
320       git-archimport(1)
321           Import an Arch repository into git.
322
323       git-cvsexportcommit(1)
324           Export a single commit to a CVS checkout.
325
326       git-cvsimport(1)
327           Salvage your data out of another SCM people love to hate.
328
329       git-cvsserver(1)
330           A CVS server emulator for git.
331
332       git-imap-send(1)
333           Send a collection of patches from stdin to an IMAP folder.
334
335       git-quiltimport(1)
336           Applies a quilt patchset onto the current branch.
337
338       git-request-pull(1)
339           Generates a summary of pending changes.
340
341       git-send-email(1)
342           Send a collection of patches as emails.
343
344       git-svn(1)
345           Bidirectional operation between a Subversion repository and git.
346

LOW-LEVEL COMMANDS (PLUMBING)

348       Although git includes its own porcelain layer, its low-level commands
349       are sufficient to support development of alternative porcelains.
350       Developers of such porcelains might start by reading about git-update-
351       index(1) and git-read-tree(1).
352
353       The interface (input, output, set of options and the semantics) to
354       these low-level commands are meant to be a lot more stable than
355       Porcelain level commands, because these commands are primarily for
356       scripted use. The interface to Porcelain commands on the other hand are
357       subject to change in order to improve the end user experience.
358
359       The following description divides the low-level commands into commands
360       that manipulate objects (in the repository, index, and working tree),
361       commands that interrogate and compare objects, and commands that move
362       objects and references between repositories.
363
364   Manipulation commands
365       git-apply(1)
366           Apply a patch to files and/or to the index.
367
368       git-checkout-index(1)
369           Copy files from the index to the working tree.
370
371       git-commit-tree(1)
372           Create a new commit object.
373
374       git-hash-object(1)
375           Compute object ID and optionally creates a blob from a file.
376
377       git-index-pack(1)
378           Build pack index file for an existing packed archive.
379
380       git-merge-file(1)
381           Run a three-way file merge.
382
383       git-merge-index(1)
384           Run a merge for files needing merging.
385
386       git-mktag(1)
387           Creates a tag object.
388
389       git-mktree(1)
390           Build a tree-object from ls-tree formatted text.
391
392       git-pack-objects(1)
393           Create a packed archive of objects.
394
395       git-prune-packed(1)
396           Remove extra objects that are already in pack files.
397
398       git-read-tree(1)
399           Reads tree information into the index.
400
401       git-symbolic-ref(1)
402           Read and modify symbolic refs.
403
404       git-unpack-objects(1)
405           Unpack objects from a packed archive.
406
407       git-update-index(1)
408           Register file contents in the working tree to the index.
409
410       git-update-ref(1)
411           Update the object name stored in a ref safely.
412
413       git-write-tree(1)
414           Create a tree object from the current index.
415
416   Interrogation commands
417       git-cat-file(1)
418           Provide content or type and size information for repository
419           objects.
420
421       git-diff-files(1)
422           Compares files in the working tree and the index.
423
424       git-diff-index(1)
425           Compares content and mode of blobs between the index and
426           repository.
427
428       git-diff-tree(1)
429           Compares the content and mode of blobs found via two tree objects.
430
431       git-for-each-ref(1)
432           Output information on each ref.
433
434       git-ls-files(1)
435           Show information about files in the index and the working tree.
436
437       git-ls-remote(1)
438           List references in a remote repository.
439
440       git-ls-tree(1)
441           List the contents of a tree object.
442
443       git-merge-base(1)
444           Find as good common ancestors as possible for a merge.
445
446       git-name-rev(1)
447           Find symbolic names for given revs.
448
449       git-pack-redundant(1)
450           Find redundant pack files.
451
452       git-rev-list(1)
453           Lists commit objects in reverse chronological order.
454
455       git-show-index(1)
456           Show packed archive index.
457
458       git-show-ref(1)
459           List references in a local repository.
460
461       git-tar-tree(1)
462           (deprecated) Create a tar archive of the files in the named tree
463           object.
464
465       git-unpack-file(1)
466           Creates a temporary file with a blob’s contents.
467
468       git-var(1)
469           Show a git logical variable.
470
471       git-verify-pack(1)
472           Validate packed git archive files.
473
474       In general, the interrogate commands do not touch the files in the
475       working tree.
476
477   Synching repositories
478       git-daemon(1)
479           A really simple server for git repositories.
480
481       git-fetch-pack(1)
482           Receive missing objects from another repository.
483
484       git-http-backend(1)
485           Server side implementation of Git over HTTP.
486
487       git-send-pack(1)
488           Push objects over git protocol to another repository.
489
490       git-update-server-info(1)
491           Update auxiliary info file to help dumb servers.
492
493       The following are helper commands used by the above; end users
494       typically do not use them directly.
495
496       git-http-fetch(1)
497           Download from a remote git repository via HTTP.
498
499       git-http-push(1)
500           Push objects over HTTP/DAV to another repository.
501
502       git-parse-remote(1)
503           Routines to help parsing remote repository access parameters.
504
505       git-receive-pack(1)
506           Receive what is pushed into the repository.
507
508       git-shell(1)
509           Restricted login shell for GIT-only SSH access.
510
511       git-upload-archive(1)
512           Send archive back to git-archive.
513
514       git-upload-pack(1)
515           Send objects packed back to git-fetch-pack.
516
517   Internal helper commands
518       These are internal helper commands used by other commands; end users
519       typically do not use them directly.
520
521       git-check-attr(1)
522           Display gitattributes information.
523
524       git-check-ref-format(1)
525           Ensures that a reference name is well formed.
526
527       git-fmt-merge-msg(1)
528           Produce a merge commit message.
529
530       git-mailinfo(1)
531           Extracts patch and authorship from a single e-mail message.
532
533       git-mailsplit(1)
534           Simple UNIX mbox splitter program.
535
536       git-merge-one-file(1)
537           The standard helper program to use with git-merge-index.
538
539       git-patch-id(1)
540           Compute unique ID for a patch.
541
542       git-peek-remote(1)
543           (deprecated) List the references in a remote repository.
544
545       git-sh-setup(1)
546           Common git shell script setup code.
547
548       git-stripspace(1)
549           Filter out empty lines.
550

CONFIGURATION MECHANISM

552       Starting from 0.99.9 (actually mid 0.99.8.GIT), .git/config file is
553       used to hold per-repository configuration options. It is a simple text
554       file modeled after .ini format familiar to some people. Here is an
555       example:
556
557           #
558           # A ´#´ or ´;´ character indicates a comment.
559           #
560
561           ; core variables
562           [core]
563                   ; Don´t trust file modes
564                   filemode = false
565
566           ; user identity
567           [user]
568                   name = "Junio C Hamano"
569                   email = "junkio@twinsun.com"
570
571
572       Various commands read from the configuration file and adjust their
573       operation accordingly. See git-config(1) for a list.
574

IDENTIFIER TERMINOLOGY

576       <object>
577           Indicates the object name for any type of object.
578
579       <blob>
580           Indicates a blob object name.
581
582       <tree>
583           Indicates a tree object name.
584
585       <commit>
586           Indicates a commit object name.
587
588       <tree-ish>
589           Indicates a tree, commit or tag object name. A command that takes a
590           <tree-ish> argument ultimately wants to operate on a <tree> object
591           but automatically dereferences <commit> and <tag> objects that
592           point at a <tree>.
593
594       <commit-ish>
595           Indicates a commit or tag object name. A command that takes a
596           <commit-ish> argument ultimately wants to operate on a <commit>
597           object but automatically dereferences <tag> objects that point at a
598           <commit>.
599
600       <type>
601           Indicates that an object type is required. Currently one of: blob,
602           tree, commit, or tag.
603
604       <file>
605           Indicates a filename - almost always relative to the root of the
606           tree structure GIT_INDEX_FILE describes.
607

SYMBOLIC IDENTIFIERS

609       Any git command accepting any <object> can also use the following
610       symbolic notation:
611
612       HEAD
613           indicates the head of the current branch (i.e. the contents of
614           $GIT_DIR/HEAD).
615
616       <tag>
617           a valid tag name (i.e. the contents of $GIT_DIR/refs/tags/<tag>).
618
619       <head>
620           a valid head name (i.e. the contents of
621           $GIT_DIR/refs/heads/<head>).
622
623       For a more complete list of ways to spell object names, see "SPECIFYING
624       REVISIONS" section in git-rev-parse(1).
625

FILE/DIRECTORY STRUCTURE

627       Please see the gitrepository-layout(5) document.
628
629       Read githooks(5) for more details about each hook.
630
631       Higher level SCMs may provide and manage additional information in the
632       $GIT_DIR.
633

TERMINOLOGY

635       Please see gitglossary(7).
636

ENVIRONMENT VARIABLES

638       Various git commands use the following environment variables:
639
640   The git Repository
641       These environment variables apply to all core git commands. Nb: it is
642       worth noting that they may be used/overridden by SCMS sitting above git
643       so take care if using Cogito etc.
644
645       GIT_INDEX_FILE
646           This environment allows the specification of an alternate index
647           file. If not specified, the default of $GIT_DIR/index is used.
648
649       GIT_OBJECT_DIRECTORY
650           If the object storage directory is specified via this environment
651           variable then the sha1 directories are created underneath -
652           otherwise the default $GIT_DIR/objects directory is used.
653
654       GIT_ALTERNATE_OBJECT_DIRECTORIES
655           Due to the immutable nature of git objects, old objects can be
656           archived into shared, read-only directories. This variable
657           specifies a ":" separated (on Windows ";" separated) list of git
658           object directories which can be used to search for git objects. New
659           objects will not be written to these directories.
660
661       GIT_DIR
662           If the GIT_DIR environment variable is set then it specifies a path
663           to use instead of the default .git for the base of the repository.
664
665       GIT_WORK_TREE
666           Set the path to the working tree. The value will not be used in
667           combination with repositories found automatically in a .git
668           directory (i.e. $GIT_DIR is not set). This can also be controlled
669           by the --work-tree command line option and the core.worktree
670           configuration variable.
671
672       GIT_CEILING_DIRECTORIES
673           This should be a colon-separated list of absolute paths. If set, it
674           is a list of directories that git should not chdir up into while
675           looking for a repository directory. It will not exclude the current
676           working directory or a GIT_DIR set on the command line or in the
677           environment. (Useful for excluding slow-loading network
678           directories.)
679
680   git Commits
681       GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, GIT_AUTHOR_DATE, GIT_COMMITTER_NAME,
682       GIT_COMMITTER_EMAIL, GIT_COMMITTER_DATE, EMAIL
683           see git-commit-tree(1)
684
685   git Diffs
686       GIT_DIFF_OPTS
687           Only valid setting is "--unified=??" or "-u??" to set the number of
688           context lines shown when a unified diff is created. This takes
689           precedence over any "-U" or "--unified" option value passed on the
690           git diff command line.
691
692       GIT_EXTERNAL_DIFF
693           When the environment variable GIT_EXTERNAL_DIFF is set, the program
694           named by it is called, instead of the diff invocation described
695           above. For a path that is added, removed, or modified,
696           GIT_EXTERNAL_DIFF is called with 7 parameters:
697
698               path old-file old-hex old-mode new-file new-hex new-mode
699
700           where:
701
702       <old|new>-file
703           are files GIT_EXTERNAL_DIFF can use to read the contents of
704           <old|new>,
705
706       <old|new>-hex
707           are the 40-hexdigit SHA1 hashes,
708
709       <old|new>-mode
710           are the octal representation of the file modes.
711
712       + The file parameters can point at the user’s working file (e.g.
713       new-file in "git-diff-files"), /dev/null (e.g. old-file when a new file
714       is added), or a temporary file (e.g. old-file in the index).
715       GIT_EXTERNAL_DIFF should not worry about unlinking the temporary file
716       --- it is removed when GIT_EXTERNAL_DIFF exits.
717
718       + For a path that is unmerged, GIT_EXTERNAL_DIFF is called with 1
719       parameter, <path>.
720
721   other
722       GIT_MERGE_VERBOSITY
723           A number controlling the amount of output shown by the recursive
724           merge strategy. Overrides merge.verbosity. See git-merge(1)
725
726       GIT_PAGER
727           This environment variable overrides $PAGER. If it is set to an
728           empty string or to the value "cat", git will not launch a pager.
729           See also the core.pager option in git-config(1).
730
731       GIT_SSH
732           If this environment variable is set then git fetch and git push
733           will use this command instead of ssh when they need to connect to a
734           remote system. The $GIT_SSH command will be given exactly two
735           arguments: the username@host (or just host) from the URL and the
736           shell command to execute on that remote system.
737
738           To pass options to the program that you want to list in GIT_SSH you
739           will need to wrap the program and options into a shell script, then
740           set GIT_SSH to refer to the shell script.
741
742           Usually it is easier to configure any desired options through your
743           personal .ssh/config file. Please consult your ssh documentation
744           for further details.
745
746       GIT_FLUSH
747           If this environment variable is set to "1", then commands such as
748           git blame (in incremental mode), git rev-list, git log, and git
749           whatchanged will force a flush of the output stream after each
750           commit-oriented record have been flushed. If this variable is set
751           to "0", the output of these commands will be done using completely
752           buffered I/O. If this environment variable is not set, git will
753           choose buffered or record-oriented flushing based on whether stdout
754           appears to be redirected to a file or not.
755
756       GIT_TRACE
757           If this variable is set to "1", "2" or "true" (comparison is case
758           insensitive), git will print trace: messages on stderr telling
759           about alias expansion, built-in command execution and external
760           command execution. If this variable is set to an integer value
761           greater than 1 and lower than 10 (strictly) then git will interpret
762           this value as an open file descriptor and will try to write the
763           trace messages into this file descriptor. Alternatively, if this
764           variable is set to an absolute path (starting with a / character),
765           git will interpret this as a file path and will try to write the
766           trace messages into it.
767

DISCUSSION

769       More detail on the following is available from the git concepts chapter
770       of the user-manual[3] and gitcore-tutorial(7).
771
772       A git project normally consists of a working directory with a ".git"
773       subdirectory at the top level. The .git directory contains, among other
774       things, a compressed object database representing the complete history
775       of the project, an "index" file which links that history to the current
776       contents of the working tree, and named pointers into that history such
777       as tags and branch heads.
778
779       The object database contains objects of three main types: blobs, which
780       hold file data; trees, which point to blobs and other trees to build up
781       directory hierarchies; and commits, which each reference a single tree
782       and some number of parent commits.
783
784       The commit, equivalent to what other systems call a "changeset" or
785       "version", represents a step in the project’s history, and each parent
786       represents an immediately preceding step. Commits with more than one
787       parent represent merges of independent lines of development.
788
789       All objects are named by the SHA1 hash of their contents, normally
790       written as a string of 40 hex digits. Such names are globally unique.
791       The entire history leading up to a commit can be vouched for by signing
792       just that commit. A fourth object type, the tag, is provided for this
793       purpose.
794
795       When first created, objects are stored in individual files, but for
796       efficiency may later be compressed together into "pack files".
797
798       Named pointers called refs mark interesting points in history. A ref
799       may contain the SHA1 name of an object or the name of another ref. Refs
800       with names beginning ref/head/ contain the SHA1 name of the most recent
801       commit (or "head") of a branch under development. SHA1 names of tags of
802       interest are stored under ref/tags/. A special ref named HEAD contains
803       the name of the currently checked-out branch.
804
805       The index file is initialized with a list of all paths and, for each
806       path, a blob object and a set of attributes. The blob object represents
807       the contents of the file as of the head of the current branch. The
808       attributes (last modified time, size, etc.) are taken from the
809       corresponding file in the working tree. Subsequent changes to the
810       working tree can be found by comparing these attributes. The index may
811       be updated with new content, and new commits may be created from the
812       content stored in the index.
813
814       The index is also capable of storing multiple entries (called "stages")
815       for a given pathname. These stages are used to hold the various
816       unmerged version of a file when a merge is in progress.
817

AUTHORS

819       ·   git’s founding father is Linus Torvalds <torvalds@osdl.org[6]>.
820
821       ·   The current git nurse is Junio C Hamano <gitster@pobox.com[7]>.
822
823       ·   The git potty was written by Andreas Ericsson <ae@op5.se[8]>.
824
825       ·   General upbringing is handled by the git-list
826           <git@vger.kernel.org[9]>.
827

DOCUMENTATION

829       The documentation for git suite was started by David Greaves
830       <david@dgreaves.com[10]>, and later enhanced greatly by the
831       contributors on the git-list <git@vger.kernel.org[9]>.
832

SEE ALSO

834       gittutorial(7), gittutorial-2(7), Everyday Git[1], gitcvs-migration(7),
835       gitglossary(7), gitcore-tutorial(7), gitcli(7), The Git User’s
836       Manual[2], gitworkflows(7)
837

GIT

839       Part of the git(1) suite
840

NOTES

842        1. Everyday Git
843           file:///usr/share/doc/git-1.7.1/everyday.html
844
845        2. Git User’s Manual
846           file:///usr/share/doc/git-1.7.1/user-manual.html
847
848        3. git concepts chapter of the user-manual
849           file:///usr/share/doc/git-1.7.1/user-manual.html#git-concepts
850
851        4. howto
852           file:///usr/share/doc/git-1.7.1/howto-index.html
853
854        5. GIT API documentation
855           file:///usr/share/doc/git-1.7.1/technical/api-index.html
856
857        6. torvalds@osdl.org
858           mailto:torvalds@osdl.org
859
860        7. gitster@pobox.com
861           mailto:gitster@pobox.com
862
863        8. ae@op5.se
864           mailto:ae@op5.se
865
866        9. git@vger.kernel.org
867           mailto:git@vger.kernel.org
868
869       10. david@dgreaves.com
870           mailto:david@dgreaves.com
871
872
873
874Git 1.7.1                         08/16/2017                            GIT(1)
Impressum