Git Help Center & Living Cheat Sheet

Initializes a brand new, empty local Git repository.

Creates a hidden `.git` directory inside the current folder containing the object store, ref pointers (HEAD), configuration file, and hooks infrastructure.

Clones a remote repository into a newly created local directory.

Copies the complete commit history, objects, and refs from a remote URL, checks out the default branch, and configures `origin` as the remote pointer.

Gets and sets repository or global configuration options.

Writes key-value preferences to local (`.git/config`), global (`~/.gitconfig`), or system configuration files (e.g. username, email, editor, aliases).

Displays working tree and staging index status.

Compares the three Git zones (Working Tree vs Index vs HEAD) to report untracked files, staged changes, unstaged modifications, and branch sync status.

Adds file contents to the staging area (index).

Reads file data from the Working Tree, creates SHA-1/SHA-256 blob objects in the `.git/objects` database, and records their paths in `.git/index`.

Records snapshots of the staged index changes to the repository history.

Packages the staged tree structure into a permanent cryptographically hashed Commit object, links it to current parent commit, and advances the current branch pointer.

Lists, creates, renames, or deletes branches.

Manages pointer references in `.git/refs/heads/`. A Git branch is merely a 41-byte text file storing the 40-character SHA of a commit.

Switches branches and updates working directory files.

Points the `HEAD` reference to another branch and updates files in the Working Tree and Staging Area to match the target commit snapshot.

Joins two or more development histories together.

Finds the best common ancestor commit between current branch and target branch, creates a three-way diff, and creates a new merge commit (or fast-forwards).

Reapplies commits on top of another base tip.

Calculates patch diffs for current branch commits, rewinds to common ancestor with target base, and re-executes each commit sequentially to produce a clean linear history.

Shows commit logs and cryptographic lineage.

Traverses parent pointers starting from HEAD backward in time, displaying author, date, message, and commit hashes.

Show changes between commits, commit and working tree, etc.

Computes line-by-line unified diffs comparing files between Working Tree, Staging Area, or between two arbitrary commit SHAs.

Manages and displays reference log information.

Records every single time the HEAD pointer moved in your local repository (commits, resets, checkouts, merges, rebases). Your ultimate undo safety net.

Restores working tree files or staging area.

Modern command (Git 2.23+) designed specifically to discard uncommitted working changes or unstage files without touching commit history.

Resets current HEAD to the specified state.

Moves the current branch pointer backward to an earlier commit, with flags controlling whether index and working tree are preserved or wiped.

Reverts existing commits by creating an inverse commit.

Generates a brand-new commit that applies the exact inverse mathematical diff of a specified bad commit, making it safe for public shared branches.

Stashes changes in a dirty working directory away.

Takes all modified tracked files and staged changes, saves them as a temporary shelf object in `.git/refs/stash`, and reverts your working tree to clean HEAD state.

Downloads objects and refs from another repository.

Contacts remote server (`origin`), downloads any new commits and branches, and updates remote-tracking references (`origin/main`) without modifying your local working files.

Fetches from and integrates with another repository or a local branch.

Combines `git fetch` followed immediately by `git merge FETCH_HEAD` (or `git rebase` if configured).

Updates remote refs along with associated objects.

Sends local commit objects and packfiles to the remote repository and advances the corresponding branch reference on the server.