Commit

A commit containing exactly one logical change, complete and independently sound.

A curated, human-readable record of the notable changes in each version of a project, written for the people who use it rather than the people who built it.

Copying the change from one commit onto another branch as a new commit, the standard way to backport a fix without merging everything else that came with it.

The note attached to each change in version control, conventionally a short summary line and a body explaining why, which becomes the main record of intent for anyone who later wonders why the code is the way it is.

A lightweight convention giving commit messages a machine-readable type and scope.

The Git state in which the current checkout points directly at a commit rather than a branch, harmless for looking around but a trap for new work, since commits made there belong to no branch and can quietly disappear.

The listing of changes between two versions of a file, the algorithms that compute it, and the unified format that code review, patches, and merges are built on.

The two basic ways Git joins branches, by sliding a branch pointer forward or by recording a new commit with two parents, and how the choice shapes a project's history.

Overwriting a remote branch with local history that doesn't contain it, the operation that makes rewritten history shareable and silently deletes other people's work when used carelessly.

Finding the commit that introduced a bug by binary search through history, testing the midpoint between a known-good and a known-bad version until one commit remains.

Showing, for every line of a file, the commit and author that last changed it, the starting point for finding out why code is the way it is.

Scripts Git runs automatically at points such as committing or pushing, used to check formatting and messages locally, and on servers to enforce policy or trigger deploys.

Git stores every version of a project as a graph of immutable objects named by the hashes of their contents, blobs for files, trees for directories, and commits for snapshots, which makes history tamper-evident and identical content free to store twice.

Git's shelf for uncommitted work, which clears the working tree so you can switch tasks, and the reasons a throwaway commit or a second worktree is often the better shelf.

The file of patterns telling Git which files to leave untracked, such as build output, dependencies, editor clutter, and local secrets, along with the traps of files that were already tracked and secrets already committed.

The recorded origin of a change or a claim — who made it, when, and on what evidence.

Replaying a branch's commits onto a new base, producing new commits with the same changes.

Collapsing a branch's commits into one before merging, trading granularity for a clean main history.

The intermediate snapshot in Git between the working files and the next commit, which lets a developer choose exactly which changes go into each commit, down to individual lines.

A system recording the history of a project's files, enabling branching, merging, and recovery.