The Animated Git Cheat Sheet

Turns the current folder into a Git repository with an empty history. Nothing is tracked until you add and commit it.

Downloads a repository with its whole history into a new folder, and remembers where it came from as origin.

Makes a shallow clone with just the newest commit, so a big repository downloads fast. Any number of commits works.

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

Every commit records who made it. Set your name and email once per computer.

Records your email in every commit you make. Use the one your Git host knows, so it links the commits to your account.

Makes git init start every new repository on a branch called main instead of master.

Sets the editor Git opens for commit messages and interactive rebases. This one is VS Code.

Prints every setting Git is using here, from the system, global and repository config files.

Creates your own Git command. After alias.st status, typing git st runs git status.

Makes every git pull rebase your local commits on top of what came down, with no merge commits.

Makes every git fetch remove origin/<branch> labels for branches deleted on the remote.

On Windows, Git converts line endings to CRLF when checking files out and back to LF when committing.

Saves your username and password or token, so Git stops asking on every push and pull.

Lists what's staged for the next commit, what's changed but not staged, and files Git isn't tracking yet.

Puts the file's current changes in the staging area, ready for the next commit.

Saves everything in the staging area as a new commit, and moves the current branch to it.

Stages every change to files Git already tracks, then commits. New files still need git add first.

Deletes the file and stages the deletion, so the next commit removes it from the project.

Takes the file out of Git but leaves it on disk. Add it to .gitignore so it stays out.

Renames the file and stages the rename in one step.

Prints the .gitignore file, line number and rule that ignores the file. Prints nothing if it isn't ignored.

Deletes every file Git isn't tracking. Add -d to delete untracked folders too.

Deletes every untracked file and folder, including the ones .gitignore hides, like build output and .env files.

Lists the commits on the current branch, newest first, with their hash, author, date and message.

Includes the commits of every branch, not just the one you're on.

Draws the history of every branch as a text graph, one line per commit, with the branch labels on it.

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

Keeps listing the file's commits past the point where it was renamed. Without --follow the history stops there.

Lists the commits that changed how many times <text> appears, which is where it was added or removed.

Lists only the commits whose author's name or email contains <name>.

Lists only the commits made in that window. Dates like 2024-05-01 work too.

Shows a commit's message and the changes it made.

Prints the file with the commit, author and date that last changed each line.

Lists everyone who made commits on the current branch, with how many each, most first.

Prints a name like v1.0-2-g1a2b3c4: the latest tag, how many commits since it, and the commit's short hash.

Finds <text> in every tracked file and prints each matching line with its file and line number.

Checks out the commit halfway between a bad one and a good one. Mark each test with git bisect good or git bisect bad until Git names the culprit.

Shows the lines you've changed but haven't staged yet.

Shows the lines you've staged, which is exactly what the next commit will contain.

Shows everything that changed between two commits, branches or tags.

Shows every difference between the tips of the two branches.

Lists each changed file with how many lines were added and removed, instead of the lines themselves.

Puts a new branch label on the current commit. You stay on the branch you're on.

Lists your local branches, then the remote-tracking ones like remotes/origin/main. The * marks the one you're on.

Lists each branch with its latest commit and the remote branch it tracks, like [origin/main: ahead 1, behind 2].

Lists the branches whose commits are all in the current branch already.

Lists the branches that have commits the current branch doesn't. Deleting one needs -D.

Moves HEAD to the branch and updates your files to match its latest commit.

Goes back to whichever branch you were on before this one. Run it again to flip back.

When only origin/<branch> exists, Git creates a local branch from it that tracks it, and switches to it.

Creates the branch on the current commit and switches to it in one step.

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

Moves the label to a new name. The commits don't change.

Removes the label. Git refuses if the branch has commits that aren't merged anywhere.

Removes the label even when its commits aren't merged. Only the reflog still knows them.

Moves HEAD onto the commit itself, not a branch (a detached HEAD). Good for looking around.

Brings the branch's commits into yours with a merge commit that has two parents.

When your branch has nothing of its own, Git just slides its label forward (a fast-forward). No merge commit.

Makes a merge commit even when a fast-forward would do, so the branch still shows in history.

Stages all of the branch's changes without committing. Your next commit holds them as one.

Once you've fixed the conflicted files and staged them with git add, this makes the merge commit.

Stops the merge and puts everything back the way it was before it started.

Copies your branch's commits onto the tip of <branch>, one by one, as new commits with new hashes.

Opens a list of your commits after <base>. Change pick to squash, reword or drop, or reorder the lines.

Moves only the commits after <old-base> onto <new-base>, leaving the rest behind.

Once the conflict is fixed and staged, this commits it and replays the rest.

Leaves out the commit that stopped the rebase and carries on with the rest.

Stops the rebase and returns the branch to where it was before it started.

Applies the changes of one commit from anywhere as a new commit on your branch.

Copies every commit after <from> up to <to>, in order.

Gives a remote repository a short name, so you can fetch from it and push to it.

Lists each remote with the URL Git fetches from and the one it pushes to.

Asks the remote for its branches and shows which ones you track, which are new, and what git pull and git push do for each of yours.

Points the remote at a new address, like after a repository moves or you switch from HTTPS to SSH.

Renames the remote, and its remote-tracking branches and branch settings with it.

Deletes the link to the remote and its remote-tracking branches. The remote repository itself isn't touched.

Asks the remote for every branch and tag it has and the commit each points to. Nothing is downloaded.

Sets the remote branch your current branch tracks, so plain git pull and git push know where to go.

Downloads what's new on the remote and updates origin/<branch>. Your own branches and files don't change.

Fetches from each remote in turn, like origin and upstream in a fork, and updates all their remote-tracking branches.

Fetches, then removes origin/<branch> labels for branches that were deleted on the remote.

Fetches, then merges the remote branch into yours. Makes a merge commit when both sides have new commits.

Fetches <branch> from origin and merges it into the branch you're on, whatever that branch tracks.

Fetches, then replays your local commits on top of what came down, so history stays in one line.

Sends your branch's new commits to the remote branch it tracks.

Creates the branch on the remote and links yours to it, so plain git push and git pull work from then on.

Replaces the remote branch with yours after a rebase or amend, but refuses if someone pushed since you last fetched.

Replaces the remote branch with yours, whatever is there.

Removes the branch from the remote. Your local branch stays.

Puts a permanent label, like v1.0, on the current commit. Unlike a branch, a tag never moves.

Makes an annotated tag, which stores who tagged it, when, and a message. Use these for releases.

Lists every tag in alphabetical order.

Removes the tag from your repository. The commit stays.

Sends a single tag, and any commits it needs, to the remote.

Tags stay local until you push them. This sends every tag the remote doesn't have.

Removes the tag from the remote. Your local tag stays until you run git tag -d <tag>.

Saves your staged and unstaged changes on the stash and resets the working directory to the last commit.

Stashes untracked files along with your changes. Plain git stash leaves them where they are.

Stashes your changes under a message of your own, so git stash list tells you what each entry is.

Stashes the changes to the files you name and leaves every other change where it is.

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

Applies the newest entry to your files and removes it from the stash.

Applies the newest entry but leaves it on the stash, so you can apply it again elsewhere.

Deletes the newest entry. Name one to drop, like stash@{1}.

Shows the changes the newest entry holds, line by line. Name an entry to look at another, like stash@{1}.

Creates a branch at the commit you stashed from, applies the entry there and drops it. Good when the stash no longer applies cleanly.

Empties the stash, deleting every entry at once.

Checks the branch out in a second folder that shares this repository, so you don't have to switch back and forth.

Lists every folder checked out from this repository, with its commit and branch.

Clears Git's record of worktrees whose folders no longer exist, so their branches can be checked out again.

Takes the file out of the next commit. Your edits stay in the file.

Puts the file back the way it was at the last commit. git restore . does every file.

Puts every file in the current folder back the way it was at the last commit. Staged changes stay staged.

The command Git had before restore. The -- means what follows is a file or folder, not a branch.

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

Replaces the last commit with a new one. Stage a forgotten file first, or change the message with -m.

Moves the branch back one commit. The commit's changes wait in the staging area, ready to commit again.

Moves the branch back one commit and unstages its changes. The files keep every edit.

Moves the branch to <commit> and makes the staging area and every file match it.

Throws away your local commits and changes on the branch and moves it to where the remote's is. Run git fetch first.

Adds a new commit that reverses <commit>. History stays intact, so it's safe on a shared branch.

Reverses everything a merge brought in. -m 1 keeps the side you merged into.

Reverses every commit after <from> up to <to> and stages the result without committing, so one commit undoes them all.

Lists every commit HEAD has pointed to, including ones no branch reaches anymore. Copy the hash you need.

HEAD@{1} is wherever HEAD was one move ago, so this jumps back past the reset that lost your commits.

Git prints the hash when it deletes a branch. Point a new branch at it and nothing is lost.