Git Core Message Reference

Git's internal object database is missing or corrupted.

The operating system denied Git's request for more RAM during a heavy operation.

Git detected corruption inside one of its compressed data bundles (packfiles).

An uncompressed file in Git's internal database has an invalid checksum or zero bytes.

The internal staging area database file has become corrupted.

A loose object file exists on disk but holds zero bytes, breaking reads.

Git paused the merge because it cannot automatically resolve overlapping changes.

Git aborted the merge to protect uncommitted changes in your working directory.

Git prevented a branch switch because it would overwrite unsaved changes in your working directory.

Git aborted the merge because it would overwrite untracked files in your working directory.

Git rejected your push because the remote repository contains commits missing from your local branch.

Git rejected your push because your branch is behind the remote, preventing a linear update.

The remote server actively refused to accept your pushed commits due to server-side rules.

Your local branch and the remote tracking branch have both received different commits.

The remote server could not locate the repository at the specified URL.

Git refused to run because the repository folder is owned by a different system user.

The remote server rejected your SSH connection because it did not recognize your SSH key.

Git failed to establish a data connection with the remote repository.

The server rejected your credentials during an HTTPS connection.

Your computer's DNS could not find the IP address for the remote repository's domain name.

The connection to the server was closed abruptly before Git finished transferring data.

The underlying HTTP client (cURL) failed to complete the network request.

Git received an End-Of-File signal before it finished downloading the expected repository data.

Git failed to save changes to the staging area due to a filesystem issue.

Git could not update a specific branch pointer because it is locked or corrupted.

Git stopped a rebase or cherry-pick because the commit conflicts with your current code.

Git found a submodule reference without a matching configuration entry.

Git successfully cloned the main repository but failed to download a required submodule.

Git could not check out a file because its path exceeds the OS length limit.

Git could not apply a patch file because the target code has changed too much.

Git refused to merge two projects because they do not share a common ancestor commit.

Your sparse-checkout rules excluded all files, leaving your working directory empty.

Reapplying a stash hit conflicts, and the stash entry was deliberately kept.

A fast-forward-only integration was refused because local and fetched histories diverged.

GitHub refused the push because branch protection rules blocked updating the target ref.

A push into a non-bare repository's active branch was denied by that repository's settings.

The remote address answered, but the path behind it holds no Git repository.

Git needed credentials, found prompting disabled, and no helper supplied them.

The corporate proxy answered the tunnel request with HTTP 407, demanding authentication.

The helper unpacking a fetched pack produced output the fetcher could not interpret.

The stream fetched from the server did not start with a valid packfile header.

The TLS layer found no trusted issuer to complete the server's certificate chain.

The certificate presented by the server was rejected because its issuer revoked it.

Git could not write a new object file because the object database denied the write.

A submodule configuration stanza names its path but carries no url key.

Stash application failed while copying the stash's untracked files back out.

TLS verification of the remote host failed outright, naming the CA file and CRL file.

A clean or smudge filter program exited nonzero and the file operation aborted.

You have unresolved file conflicts preventing Git from completing the current operation.

You tried to add a remote named 'origin', but one with that name already exists.

Git does not know which remote branch should receive your pushed commits.

You checked out a specific commit, detaching your working directory from the branch history.

Git could not find the local branch you are trying to push.

Git could not find the file or directory you specified in your command.

The remote repository's default branch points to a branch that does not exist.

Git could not find the hidden directory required to execute commands.

Git cannot run because another Git process is currently modifying the repository.

Git cannot resolve 'HEAD' because the repository has no commits yet.

You tried to run a Git command while a previous rebase operation is still paused.

A local script (hook) executed by Git failed, forcing Git to abort the commit.

Git refused to create a commit because you haven't configured your name and email.

Git doesn't know whether you are referring to a branch name or a file path.

You attempted to create a Git tag using a name that is already taken.

Git cannot add a submodule because a Git repository already occupies that path.

Git cannot parse its configuration file due to a syntax error.

Git could not parse your input as a valid commit, branch, or file path.

Your local branch contains commits that have not yet been pushed to the remote server.

Git refused a pull configured for rebase because tracked files carry uncommitted edits.

Git declined to start a rebase while the working tree holds unstaged modifications.

A branch switch or similar operation stopped because the index still holds unmerged entries.

The command ran inside a bare repository or a Git directory, where no checkout exists.

Committing selected paths was refused because a merge must be recorded as one unit.

Status reports both the local branch and its upstream holding separate new commits.

The invoked subcommand is not among the commands this Git installation provides.

Git warns that LF line endings will become CRLF on a file next rewrite.

The --unshallow flag was passed to a fetch in a repository that is not shallow.