The Animated Git Cheat Sheet

Creates an empty Git repository in the current folder, stored in a hidden .git folder. No files are tracked until you add and commit them.

Downloads the repository at <url> with its full history into a new folder, checks out its default branch, and adds the source as the remote origin.

Clones only the <N> latest commits of the default branch, leaving out the older history.

Clones the repository and checks out <branch> instead of the remote's default branch.

Sets the name Git records as the author and committer of each new commit.

Sets the email address Git records for the author and committer of each new commit.

Sets the name git init gives the first branch of a new repository.

Sets the editor Git opens for commit messages and interactive rebases. For VS Code, use code --wait so Git waits until the file is closed.

Prints every setting from the system, global, and repository config files. When a setting is in more than one file, the repository value overrides the global value, and the global value overrides the system value.

Sets <setting> to <value> in the system config file, which applies to every user and repository on the machine. A global or repository value for the same setting overrides it.

Creates a Git command named <name> that runs <command>. For example, alias.st status makes git st run git status.

Makes git pull rebase your local commits onto the fetched commits instead of creating a merge commit.

Makes git fetch delete remote-tracking branches, like origin/<branch>, whose branches no longer exist on the remote.

Converts LF line endings to CRLF when files are checked out, and back to LF when they're committed.

Stores your username and password or token with <helper>, like manager on Windows or osxkeychain on macOS, so Git doesn't ask for them each time.

Shows the active branch, staged changes, unstaged changes, and untracked files. During a merge, rebase, or cherry-pick, it also shows that operation's state and the next step.

Stages the current changes to <file>, so they're included in the next commit.

Stages every new, modified, and deleted file in the current folder and its subfolders.

Stages every new, modified, and deleted file in the repository, whichever folder it's run from.

Creates a new commit from the staged changes with the message <message>, and moves the active branch to it.

Stages the changes to all tracked files and commits them with the message <message>. Untracked files aren't included.

Deletes <file> from the working directory and stages the deletion.

Removes <file> from the staging area, so the next commit stops tracking it. The file stays in the working directory.

Renames or moves <old> to <new> and stages the change.

Prints the ignore file, line number, and pattern that ignore <file>. Prints nothing if the file isn't ignored.

Deletes the untracked files in the working directory. Add -d to delete untracked folders too.

Deletes all untracked files and folders, including ignored ones like build output and .env files.

Lists the commits in the active branch's history, newest first, with each commit's hash, author, date, and message.

Lists the commits in the history of every branch and tag, not only the active branch.

Prints the history of all branches as a text graph, one line per commit, with branch and tag names next to their commits.

Lists the commits that changed <file>, each with the lines it added and removed.

Lists the commits that changed <file>, including the ones from before it was renamed.

Lists the commits that added or removed <text>, found by checking where the number of times <text> appears changes.

Lists the commits whose author name or email matches <name>.

Lists the commits made between the two dates. Exact dates like 2024-05-01 and relative ones like 2 weeks ago both work.

Shows a commit's hash, author, date, and message, followed by the changes it made.

Prints each line of <file> with the commit, author, and date that last changed it.

Lists each author who made commits on the active branch, with their number of commits, highest first.

Names the current commit after the most recent annotated tag in its history, like v1.0-2-g1a2b3c4: the tag v1.0, 2 commits since it, and g followed by the commit's short hash.

Searches every tracked file for <text> and prints each matching line with its file name and line number.

Starts a binary search between the <bad> and <good> commits by checking out the commit halfway between them. Test each commit Git checks out and mark it with git bisect good or git bisect bad until Git reports the first bad commit.

Shows the changes in the working directory that aren't staged yet, line by line.

Shows the staged changes line by line, which is what the next commit will contain.

Shows the changes between two commits. Branch and tag names work in place of commit hashes.

Shows the changes between the latest commits of the two branches.

Lists each file with unstaged changes and the number of lines added and removed in it.

Creates a branch named <name> that points to the current commit. HEAD stays on the active branch.

Lists local branches, then remote-tracking branches like remotes/origin/main. A * marks the active branch.

Lists each local branch with its latest commit, its upstream branch, and how many commits it's ahead or behind, like [origin/main: ahead 1, behind 2].

Lists the branches whose latest commit is already in the active branch's history.

Lists the branches that have commits not in the active branch's history.

Points HEAD at <branch> and updates the staging area and working directory to match its latest commit.

Switches to the branch that was active before the current one.

When no local branch named <branch> exists but origin/<branch> does, creates the local branch from it, sets it to track origin/<branch>, and switches to it.

Creates a branch named <name> at the current commit and switches to it.

Creates a branch named <name> at <start>, which can be a commit hash, a tag, or a branch like origin/main, and switches to it.

Renames the branch <old> to <new>. Its commits don't change.

Deletes the branch <name>. Git refuses if the branch has commits that aren't merged into its upstream branch, or into the active branch if it has no upstream.

Deletes the branch <name> even if it has unmerged commits. Afterward, those commits are reachable only through the reflog.

Points HEAD directly at <commit> instead of at a branch, and updates the working directory to match. Create a branch before committing there.

Merges <branch> into the active branch. When both have new commits, Git creates a merge commit with two parents.

When the active branch has no commits that <branch> lacks, Git moves the active branch forward to <branch>'s latest commit. No merge commit is created.

Creates a merge commit even when a fast-forward is possible, so the merged branch stays visible in the history.

Stages the combined changes from <branch> without committing or recording a merge. The next commit contains them as one commit.

Creates the merge commit once the conflicts are resolved and the files are staged with git add.

Stops the merge and returns the branch, staging area, and working directory to their state before it started.

Replays the active branch's commits on top of <branch>, one at a time, as new commits with new hashes.

Opens an editable list of the commits after <base>. Change pick to reword, squash, or drop, or reorder the lines, and Git replays the commits as listed when you save and close the file.

Replays only the commits after <old-base> onto <new-base>. The commits before <old-base> stay where they are.

After the conflicts are resolved and staged, commits the stopped commit and continues replaying the remaining commits.

Skips the commit that caused the conflict and continues replaying the remaining commits.

Stops the rebase and returns the branch to the commit it pointed to before the rebase started.

Applies the changes from <commit> to the active branch as a new commit.

Applies each commit after <from> up to and including <to>, in order, as new commits on the active branch.

Adds a remote named <name> for the repository at <url>, so you can fetch from it and push to it.

Lists each remote with its fetch URL and push URL.

Shows the remote's URLs, its branches, which of them are tracked, and what git pull and git push do for each local branch.

Changes the URL of the remote <name> to <url>.

Renames the remote <old> to <new>, along with its remote-tracking branches and settings.

Removes the remote <name> with its remote-tracking branches and settings. The remote repository itself isn't affected.

Lists the remote's branches and tags and the commit each points to, without downloading anything.

Sets origin/<branch> as the active branch's upstream, so plain git pull and git push use it.

Downloads new commits from the remote and updates its remote-tracking branches, like origin/main. Local branches and the working directory don't change.

Downloads only <branch>'s new commits from <remote> and updates <remote>/<branch>. Local branches and the working directory don't change.

Fetches from every remote, like origin and upstream, and updates all their remote-tracking branches.

Fetches, then deletes remote-tracking branches, like origin/<branch>, whose branches no longer exist on the remote.

Fetches the active branch's upstream and merges it into the active branch. When both have new commits, Git creates a merge commit.

Fetches <branch> from origin and merges it into the active branch, even if the active branch tracks a different branch.

Fetches the active branch's upstream, then replays your local commits on top of it instead of merging.

Sends the active branch's new commits to its upstream branch on the remote.

Creates <branch> on origin, pushes its commits, and sets it as the local branch's upstream.

Overwrites the remote branch with your local branch, but only if the remote branch hasn't changed since your last fetch.

Overwrites the remote branch with your local branch, even if the remote has commits you don't have.

Deletes <branch> on the remote. The local branch isn't affected.

Creates a lightweight tag named <name> that points to the current commit.

Creates an annotated tag named <name> on the current commit, storing the tagger, the date, and <message>.

Lists all tags in alphabetical order.

Deletes the local tag <name>. The commit it pointed to isn't affected.

Pushes the tag <tag>, and any commits it needs, to the remote.

Pushes every local tag the remote doesn't have yet.

Deletes the tag <tag> on the remote. The local tag isn't affected.

Saves the staged and unstaged changes to tracked files as a new stash entry, and resets the staging area and working directory to the last commit.

Stashes untracked files as well as the changes to tracked files.

Stashes the changes as an entry with the message <message>, which git stash list shows.

Stashes only the changes to <file>, leaving all other changes in place.

Lists every stash entry, newest first, as stash@{0}, stash@{1}, and so on.

Applies the latest stash entry to the working directory and removes it from the stash. If applying it conflicts, the entry is kept.

Applies the latest stash entry to the working directory and keeps it on the stash.

Deletes the latest stash entry, or the one named, like stash@{1}.

Shows the changes in the latest stash entry, line by line. Name an entry to see another, like stash@{1}.

Creates the branch <name> at the commit the latest stash entry was created on, applies the entry there, and drops it if it applied cleanly.

Deletes every stash entry.

Unstages the changes to <file>, so they're not in the next commit. The file in the working directory doesn't change.

Discards the unstaged changes to <file>, restoring it from the staging area.

Discards the unstaged changes to every file in the current folder and its subfolders. Staged changes are kept.

Discards the unstaged changes in the current folder, like git restore . does. The -- marks what follows as file paths, not a branch.

Replaces <file> in the working directory with its version from <commit>. Commit the file to keep that version.

Replaces the last commit with a new commit that includes any staged changes and has the message <message>. Leave out -m to edit the existing message.

Moves the active branch back <N> commits (HEAD~1 undoes only the last one). Their changes stay staged.

Moves the active branch back <N> commits (HEAD~1 undoes only the last one) and unstages their changes. The working directory doesn't change.

Moves the active branch to <commit> and resets the staging area and working directory to match it.

Moves the active branch to origin/<branch> and resets the staging area and working directory to match, discarding local commits and changes. Run git fetch first.

Creates a new commit that reverses the changes from <commit>. Existing commits aren't rewritten, so it's safe on shared branches.

Creates a new commit that reverses the changes a merge brought in. -m 1 makes Git reverse them relative to the merge's first parent, the branch the merge was made on.

Reverses each commit after <from> up to and including <to> and stages the result without committing, so one commit can undo them all.

Lists every commit HEAD has pointed to, newest first, including commits that no branch points to anymore.

HEAD@{1} is the commit HEAD pointed to before its last move, so this resets the branch to where it was before the reset.

Creates the branch <name> at <hash>, its last commit. Git prints the hash when it deletes a branch, and git reflog shows it too.