Git Reference Manual designed by Claude.ai for NetDTL

Reads and writes configuration variables that control all aspects of Git behaviour. Variables can be stored at three distinct hierarchical levels: system, global user, and local repository. Each level overrides the previous one. Variables set without an explicit level are written to the local .git/config file.

Displays the man page for the specified Git command. Available offline. Each Git command also accepts --help for the same result, and -h for a short summary of available options.

Creates a new Git repository by initialising the .git subdirectory in the current or specified directory. This directory holds all objects, references and metadata for the repository. If no files are present, the working tree is empty and no commit exists yet.

Retrieves a full copy of an existing Git repository, including its entire history. The remote repository is automatically registered under the short name origin. A local tracking branch is created for each remote branch, and the main branch is checked out in the working tree. Supported protocols include https://, ssh://, git:// and local paths.

Places changes in the staging area (index) to include them in the next commit. Its effect is closer to "add this content for the next snapshot" than a simple addition to the project. It is used to start tracking new files, stage modified files, and mark merge conflicts as resolved. If a directory is specified, the command recursively stages all files it contains.

Displays the state of the working tree and staging area relative to the last commit. Identifies modified, staged or untracked files, and reminds you of commands to act on each category. Also shows the current branch and its ahead/behind status relative to its tracked remote branch.

Displays line-by-line differences (patch) between different states of the repository. Without arguments, compares the working tree with the index (unstaged changes). With --staged or --cached, compares the index with the last commit (staged changes that will be part of the next commit). Can also compare two arbitrary commits or a commit with the working tree.

Records the current state of the index as a new commit object in the local repository. Each commit contains a snapshot of staged content, author and committer metadata, the date, the commit message, and a pointer to the parent commit(s). Without a message option, opens the configured editor to enter the message.

Removes files from the index and working tree in a single operation, recording the removal for the next commit. Unlike a plain system deletion, the removal is staged and will be included in the next commit.

Renames or moves a file and stages the change for the next commit. Equivalent to running mv, git rm and git add in sequence. Git detects renames implicitly anyway; this command simply simplifies the operation to one step.

Displays the commit history of the repository in reverse chronological order. For each commit, shows the SHA-1 checksum, author name and email, date, and commit message. Offers a wide range of filtering and output formatting options.

Displays detailed information about a Git object: commit (metadata and diff), annotated tag (creator information and associated commit), tree or blob. Without arguments, shows the last commit on the current branch.

Introduced in Git 2.25, a dedicated command for resetting files. Without options, resets a file in the working tree to its last committed state, discarding unstaged local changes. With --staged, unstages a file (removes it from the staging area) without touching the working tree.

A versatile command for moving the HEAD pointer and/or modifying the state of the index and working tree. With a file path, unstages the specified file (equivalent to git restore --staged). With a commit as target, repositions HEAD and acts on the index and working tree according to the chosen mode. It is the foundation of undo and history-rewriting operations in Git.

Creates a new commit that exactly reverses the changes introduced by the specified commit. Unlike git reset, does not rewrite history: the reverted commit remains in the graph. The safe method to undo commits already shared on a public repository.

Manages local branches. Without arguments, lists local branches, marking the current branch with an asterisk. A Git branch is simply a lightweight pointer to a commit; creating and deleting branches costs almost nothing.

The historic dual-purpose command: switches to an existing branch (moves HEAD and updates the working tree) or restores files in the working tree. Since Git 2.23, its two functions are better separated by git switch and git restore. When switching branches, Git resets the working tree to the state of the last commit on the target branch.

Introduced in Git 2.23 to cleanly separate the branch-switching function from file restoration. Allows changing branches, creating a new one and switching to it, or returning to the previously checked-out branch.

Integrates the history and changes of a branch into the current branch. If the target branch is a direct ancestor of the branch to merge, Git performs a fast-forward by simply moving the pointer. Otherwise, Git performs a three-way merge by creating a new merge commit with two parents. In case of conflict, the merge is interrupted and conflicting files are marked for manual resolution.

Launches a graphical merge conflict resolution tool. Git detects and suggests available tools on the system (opendiff, kdiff3, vimdiff, emerge, etc.). After resolving each conflict in the tool, the file is marked as resolved in the index.

Replays commits from a branch onto a new base, producing a linear history. Identifies the common ancestor between the current branch and the target, extracts the diffs of each commit, resets the branch to the target, then re-applies each diff in order. Unlike merging, creates no merge commit; the resulting history is more readable but rewrites SHA-1 identifiers.

Manages references to remote repositories (short names and associated URLs). Without arguments, lists the short names of registered remote repositories. Remote repositories are versions of your project hosted elsewhere (internet, local network, or even a local path).

Retrieves from the remote repository all new data (commits, branches, tags) not yet present locally. Updates only remote-tracking branches (e.g. origin/master), without touching local branches or the working tree. Merging remote data into local work must be done manually with git merge.

Combines git fetch immediately followed by git merge (or git rebase depending on configuration). Retrieves remote changes from the configured tracking branch and integrates them into the current local branch. If pull.rebase is set to true, performs a rebase instead of a merge.

Transfers commits from the local branch to the specified remote repository. The push is rejected if the remote history has diverged (someone pushed in the meantime): you must first fetch and merge the remote changes. Tags are not pushed automatically; they must be specified explicitly.

Creates, lists or deletes tags to mark important points in history (published versions, milestones). Git distinguishes two tag types: lightweight (a simple pointer to a commit) and annotated (full objects with metadata, message and optional GPG signature). Annotated tags are recommended for official releases. Tags are not pushed automatically with git push.

Temporarily saves working tree and index changes onto a stack, without creating a commit. The working tree is reset to the last commit state, allowing a context switch without committing unfinished work. Stashes can be re-applied later, including on other branches.

Searches for a pattern (regular expression or literal) in repository files, with the option to target a specific commit or tree rather than the working tree. Faster than standard grep on large repositories because it only examines tracked files.

Binary search tool through history to locate the commit that introduced a bug. Git automatically navigates history by bisection, reducing the search to O(log n) commits to test. Each commit is marked good or bad until the first defective commit is isolated. Can be fully automated with a test script.

Displays each line of a file annotated with the commit that last introduced it, as well as the author and date. Allows quickly identifying who modified a particular line of code and in which commit.

Rewrites the entire history by applying scripted filters to each commit. Allows removing a file from the entire history, modifying author metadata, changing commit messages in bulk, or splitting a subdirectory into an independent repository. Slow and irreversible operation; prefer git-filter-repo for recent versions.

Re-applies the changes introduced by one or more specific commits onto the current branch, creating equivalent new commits. Useful for importing a bug fix from one branch to another without merging the entire source branch.

"Reuse recorded resolution": memorises merge conflict resolutions already performed and automatically re-applies them when the same conflict recurs. Particularly useful on topic branches that are regularly rebased onto master. Must be enabled with git config rerere.enabled true.

Manages submodules: Git repositories nested inside a parent repository, pinned to a specific commit. Allows including and managing external dependencies (libraries, tools) while keeping their histories separate. The parent repository records only the URL and SHA-1 of the commit used for each submodule.

Runs repository maintenance tasks: compresses loose objects into pack files, removes unreachable objects (orphans, deleted refs), and optimises Git's internal structures for better performance. Git may run this command automatically in the background.

Verifies the integrity of the Git object database and detects corrupted data or orphaned objects (dangling objects). Orphaned objects are commits, trees or blobs not referenced by any branch or tag; they may represent recoverable lost work.

Packages Git objects and references into a portable binary file (bundle), allowing Git history to be transferred via network-free media (USB drive, email attachment). A bundle can be used as a remote repository for git fetch or git clone.

Creates a replacement reference that causes Git to treat one object as if it were another, without rewriting history. Useful for grafting separate histories or correcting errors in old commits without modifying SHA-1s. Replacements are stored in refs/replace/.

Displays the contents of a Git tree object (list of files and subdirectories with their modes, types and associated SHA-1s). A plumbing command used to inspect the repository's internal objects directly.

Displays the content, type or size of a Git object (blob, tree, commit, tag) identified by its SHA-1 or a symbolic reference. A fundamental command for inspecting the repository's internal objects.

Computes the SHA-1 of a file according to the Git object format and optionally stores it in the object database. A plumbing command illustrating how Git generates identifiers for its objects.

Creates a tree object in the Git database from the current index contents and returns its SHA-1. A plumbing command used in low-level scripts to manually construct commits.

Updates a Git reference (branch, tag or any refs/) to point to the specified SHA-1. The safe plumbing method for manipulating references, preferable to directly editing files in .git/refs/.

Displays the complete list of references (branches, tags, HEAD) of a remote repository with their corresponding SHA-1s, without downloading any objects. A plumbing command for querying the state of a remote repository without fetching.