Git Command Helper

Describe what you want to do and find the Git command for it, with an explanation and a warning when the command rewrites history.

What do you want to do with Git?

Popular:

59 commands

Set your name and email
Setup
Name <name>
Email <email>
git config --global user.name <name>
git config --global user.email <email>
Sets the author recorded on every commit you make on this machine. Drop --global inside a repository to override it for that repository only.
Create a new repository
Setup
git init -b main
Turns the current directory into a Git repository with main as the initial branch (-b needs Git 2.28 or newer).
Clone a repository
Setup
URL <url>
git clone <url>
Downloads the repository with its full history into a new folder named after the repository and checks out the default branch.
Clone only the latest commit (shallow clone)
Setup
URL <url>
git clone --depth 1 <url>
Fetches only the most recent commit, which is much faster for large repositories and CI jobs. Run git fetch --unshallow later if you need the full history.
Set the default branch name for new repositories
Setup
git config --global init.defaultBranch main
Makes git init create main instead of master in every new repository.
Create a new branch and switch to it
Branching
New branch <new-branch>
git switch -c <new-branch>
Creates the branch from your current commit and switches to it. Equivalent to the older git checkout -b.
Switch to an existing branch
Branching
Branch <branch>
git switch <branch>
Checks out the branch. If only origin/<branch> exists, Git creates a local tracking branch for it automatically.
List local and remote branches
Branching
git branch -a
git branch -vv
-a shows local and remote-tracking branches; -vv shows each local branch's upstream and whether it is ahead or behind.
Rename the current branch
Branching
New branch <new-branch>
git branch -m <new-branch>
Renames the branch you are on. If it was already pushed, push the new name with git push -u origin <new-branch> and delete the old remote branch.
Rename another branch
Branching
Old branch <old-branch>
New branch <new-branch>
git branch -m <old-branch> <new-branch>
Renames a branch you are not currently on. Its reflog is renamed too.
Delete a local branch
Use with careBranching
Careful: git branch -D deletes unmerged work. The commits stay recoverable through git reflog for a while (90 days by default), but are otherwise lost.
Branch <branch>
git branch -d <branch>
Deletes the branch only if it has been merged. Use -D to force-delete an unmerged branch.
Delete a remote branch
Use with careBranching
Careful: Removes the branch for everyone using the remote. Make sure it is merged or no longer needed.
Branch <branch>
git push origin --delete <branch>
Removes the branch from the remote. Other clones keep their remote-tracking ref until they run git fetch --prune.
Create a branch from a specific commit
Branching
New branch <new-branch>
Commit <commit>
git switch -c <new-branch> <commit>
Starts a new branch at any commit, tag or other branch instead of your current position.
Stage all changes and commit
Committing
Message <message>
git add -A
git commit -m <message>
git add -A stages new, modified and deleted files across the whole working tree; the commit records them with your message.
Stage only part of a file
Committing
File <file>
git add -p <file>
Walks through each change (hunk) and asks whether to stage it — useful for splitting unrelated edits into separate commits.
Change the last commit message
Use with careCommitting
Careful: Rewrites commit history. Only do this on commits you have not pushed, or on a branch nobody else uses — otherwise collaborators end up with diverged histories.
Message <message>
git commit --amend -m <message>
Replaces the most recent commit with one that has the new message (and anything currently staged).
Add forgotten files to the last commit
Use with careCommitting
Careful: Rewrites commit history. Only do this on commits you have not pushed, or on a branch nobody else uses — otherwise collaborators end up with diverged histories.
File <file>
git add <file>
git commit --amend --no-edit
Stages the file and folds it into the previous commit while keeping its message.
Create an empty commit (e.g. to re-trigger CI)
Committing
Message <message>
git commit --allow-empty -m <message>
Records a commit with no file changes, which is a common way to start a new CI run without touching code.
Unstage a file (keep the changes)
Undoing
File <file>
git restore --staged <file>
Removes the file from the staging area. Your edits stay in the working tree. Older equivalent: git reset HEAD <file>.
Discard local changes to a file
Use with careUndoing
Careful: Uncommitted changes in the file are discarded permanently — Git has no copy of them.
File <file>
git restore <file>
Restores the file to its last staged (or committed) version.
Undo the last commit but keep the changes staged
Use with careUndoing
Careful: Rewrites commit history. Only do this on commits you have not pushed, or on a branch nobody else uses — otherwise collaborators end up with diverged histories.
git reset --soft HEAD~1
Moves the branch back one commit; the commit's changes stay staged so you can edit and recommit them.
Undo the last commit and unstage its changes
Use with careUndoing
Careful: Rewrites commit history. Only do this on commits you have not pushed, or on a branch nobody else uses — otherwise collaborators end up with diverged histories.
git reset HEAD~1
The default (mixed) reset moves the branch back one commit and leaves the changes in your working tree, unstaged.
Delete the last commit and its changes
Use with careUndoing
Careful: Discards uncommitted work permanently and rewrites history. The removed commit can be recovered with git reflog for a while; uncommitted changes cannot.
git reset --hard HEAD~1
Moves the branch back one commit and resets the working tree to match, deleting the commit's changes and any uncommitted work.
Undo a pushed commit safely (revert)
Undoing
Commit <commit>
git revert <commit>
Creates a new commit that applies the inverse of the given commit. History is not rewritten, so it is safe on shared branches. For a merge commit add -m 1.
Make a local branch match the remote exactly
Use with careUndoing
Careful: Deletes local commits that were not pushed and all uncommitted changes. Consider git branch backup first.
Branch <branch>
git fetch origin
git reset --hard origin/<branch>
Throws away local commits and changes on the current branch and points it at the remote's version.
Restore a file from an older commit
Use with careUndoing
Careful: Overwrites uncommitted changes to that file.
Commit <commit>
File <file>
git restore --source <commit> <file>
Overwrites the file in your working tree with its content at the given commit. Add --staged --worktree to stage it too.
Show a compact history graph
History
git log --oneline --graph --decorate --all
One line per commit with an ASCII graph of branches and merges, including all branches and tags.
Show the history of a file
History
File <file>
git log --follow -p -- <file>
Lists every commit that changed the file, with diffs. --follow continues through renames.
See who last changed each line
History
File <file>
git blame <file>
Annotates each line with the commit, author and date that last modified it. Add -w to ignore whitespace changes.
Search commit messages or code changes
History
Search text <text>
git log --grep=<text>
git log -S <text> --oneline
--grep searches commit messages; -S (the pickaxe) finds commits that added or removed the given text in the code.
Show staged and unstaged changes
History
git diff
git diff --staged
git diff shows unstaged changes; --staged shows what the next commit will contain.
See commits on one branch that are not on another
History
Other branch <other-branch>
Branch <branch>
git log --oneline <other-branch>..<branch>
git diff <other-branch>...<branch>
The first command lists commits reachable from the branch but not from the other; the three-dot diff shows changes since the branches diverged.
Find the commit that introduced a bug
History
Commit <commit>
git bisect start
git bisect bad
git bisect good <commit>
git bisect reset
Binary-searches history: mark the current commit bad and a known-good commit, then test each commit Git checks out and answer git bisect good or git bisect bad until it names the culprit. git bisect reset returns you to where you started.
Show configured remotes
Remote
git remote -v
Lists each remote with its fetch and push URLs.
Add a remote
Remote
Remote <remote>
URL <url>
git remote add <remote> <url>
Registers another repository under a short name. A common pattern for forks is adding the original as upstream.
Change a remote's URL (e.g. HTTPS to SSH)
Remote
Remote <remote>
URL <url>
git remote set-url <remote> <url>
Points an existing remote at a new URL — needed after a repository moves or when switching from HTTPS to SSH.
Push a new branch and set its upstream
Remote
Branch <branch>
git push -u origin <branch>
Pushes the branch and remembers origin/<branch> as its upstream, so later git push and git pull need no arguments.
Fetch and remove deleted remote branches
Remote
git fetch --prune
Downloads new commits and deletes remote-tracking refs (like origin/old-feature) whose branch was deleted on the remote.
Pull with rebase instead of merge
Remote
git pull --rebase
Fetches and replays your unpushed local commits on top of the remote branch, avoiding a merge commit. Make it the default with git config --global pull.rebase true.
Force-push safely after rewriting history
Use with careRemote
Careful: Replaces the remote branch's history. Never force-push shared branches like main without agreement from your team.
git push --force-with-lease
Overwrites the remote branch, but refuses if someone else pushed commits you have not fetched. Prefer it over --force.
Stash changes with a message
Stash
Message <message>
git stash push -m <message>
git stash push -u -m <message>
Saves uncommitted changes and cleans the working tree. -u also stashes untracked files.
List and re-apply stashes
Stash
Stash <stash>
git stash list
git stash apply <stash>
git stash pop
apply re-applies a stash and keeps it; pop applies the most recent stash and removes it if there are no conflicts.
Delete a stash
Use with careStash
Careful: Dropped stashes are not in the reflog. They can sometimes be found with git fsck, but treat this as permanent.
Stash <stash>
git stash drop <stash>
Removes one stash entry. git stash clear removes all of them.
Merge a branch into the current branch
Rebase & merge
Branch <branch>
git merge --no-ff <branch>
Merges the branch and always records a merge commit, keeping the feature visible as a unit in history.
Rebase a feature branch onto the latest main
Use with careRebase & merge
Careful: Rewrites the branch's commits. Do not rebase a branch others have based work on; afterwards you will need git push --force-with-lease.
git fetch origin
git rebase origin/main
Replays your branch's commits on top of the current origin/main, giving a linear history. Resolve conflicts, git add them and run git rebase --continue.
Squash the last N commits into one
Use with careRebase & merge
Careful: Rewrites commit history. Only do this on commits you have not pushed, or on a branch nobody else uses — otherwise collaborators end up with diverged histories.
Number of commits <n>
git rebase -i HEAD~<n>
Opens an editor listing the last N commits; change pick to squash (or fixup) on every line except the first. Non-interactive alternative: git reset --soft HEAD~<n> then commit.
Abort a merge or rebase in progress
Rebase & merge
git merge --abort
git rebase --abort
Returns the branch to the state before the merge or rebase started.
Copy a commit from another branch
Rebase & merge
Commit <commit>
git cherry-pick <commit>
Applies the changes of one commit on top of the current branch as a new commit. Add -x to record the original commit hash in the message.
Resolve a conflict by taking one side
Use with careRebase & merge
Careful: Discards the other side's changes to that file.
File <file>
git checkout --theirs -- <file>
git add <file>
During a merge, --theirs takes the incoming branch's version and --ours keeps yours. During a rebase the meanings are swapped.
Create and push an annotated tag
Tags
Tag <tag>
Message <message>
git tag -a <tag> -m <message>
git push origin <tag>
Annotated tags store the tagger, date and message — use them for releases. Tags are not pushed by git push unless you push them explicitly.
List tags
Tags
git tag -l
git tag -l "v1.*"
Lists tags alphabetically; pass a pattern to filter. git describe --tags shows the closest tag to the current commit.
Delete a tag locally and on the remote
Use with careTags
Careful: Anyone who already fetched the tag keeps it; re-using a tag name for a different commit confuses consumers.
Tag <tag>
git tag -d <tag>
git push origin --delete <tag>
Removes the tag from your repository and from the remote.
Remove untracked files and directories
Use with careCleanup
Careful: Untracked files are deleted permanently — they are not in Git, so they cannot be recovered. Always run the dry run first.
git clean -nd
git clean -fd
-n is a dry run that lists what would be deleted; -f deletes, -d includes directories. Add -x to also delete ignored files.
Find and delete branches already merged
Cleanup
Branch <branch>
git fetch --prune
git branch --merged main
git branch -d <branch>
Lists local branches fully merged into main; delete each with -d, which refuses to delete unmerged work.
Stop tracking a file but keep it locally
Cleanup
File <file>
git rm --cached <file>
Removes the file from the index so the next commit deletes it from the repository, while leaving it on disk. Add it to .gitignore so it is not re-added.
Recover a lost commit with the reflog
Recovery
New branch <new-branch>
Commit <commit>
git reflog
git switch -c <new-branch> <commit>
The reflog records every position HEAD has had. Find the hash of the lost commit and create a branch at it.
Restore a deleted branch
Recovery
Branch <branch>
Commit <commit>
git reflog
git branch <branch> <commit>
Look up the last commit of the deleted branch in the reflog (or in the output of git branch -D, which prints it) and recreate the branch there.
Undo a reset, rebase or amend
Use with careRecovery
Careful: reset --hard discards uncommitted changes in your working tree.
git reflog
git reset --hard HEAD@{1}
HEAD@{1} is where HEAD was before the last operation. Check the reflog first to pick the right entry.
Recover a dropped stash
Recovery
Commit <commit>
git fsck --no-reflog --unreachable | grep commit
git stash apply <commit>
Dropped stashes remain as unreachable commits until garbage collection. Inspect candidates with git show <commit> and apply the right one.

How to use this tool

Describe what you want to do in the search box — for example *undo last commit*, *rename branch* or *recover deleted branch*. Results update as you type.
Narrow the list with a category chip: setup, branching, committing, undoing, history, remote, stash, rebase & merge, tags, cleanup or recovery.
Read the explanation on the card, and pay attention to any Careful warning — it marks commands that rewrite history or discard work.
Fill in placeholders such as <branch> or <commit> in the small inputs on the card. The command updates live; branch and tag names are checked against Git's naming rules and values are shell-quoted when needed.
Click Copy next to a command and run it in your terminal.

Example

Search for a task

undo last commit

Common use cases

Undoing a commit or a git add without losing work.
Looking up the exact syntax for rarely used commands like git bisect, git remote set-url or git push origin --delete.
Recovering a branch or commit after a bad reset or rebase.
Teaching Git to new team members with explanations and clear warnings.
Cleaning up merged branches, stale remote-tracking refs and untracked build artefacts.
Comparing changes before committing, alongside the Text Diff tool for arbitrary snippets.

Choosing the right Git command

Git has several commands that look similar but behave very differently, and the right choice usually depends on one question: have the commits been pushed? Commands like git commit --amend, git reset, git rebase and squashing rewrite commits — they create new commit IDs. That is harmless on a private branch but causes diverged histories for anyone who already pulled the old commits. For commits on a shared branch, git revert is the safe way to undo, because it adds a new commit instead of removing old ones.

Modern Git (2.23+) split the overloaded git checkout into two clearer commands: git switch changes branches (git switch -c creates one) and git restore changes files (git restore --staged unstages, git restore <file> discards edits). The catalog uses these where they apply, and mentions the older equivalents in the explanations so you recognise them in existing documentation.

The three modes of git reset are a frequent source of lost work. --soft moves the branch but keeps changes staged, the default --mixed keeps them unstaged in your working tree, and --hard discards them. Committed work is rarely truly lost: the reflog records every position HEAD has had for about 90 days, so git reflog followed by git switch -c <new-branch> <commit> or git reset --hard HEAD@{1} can recover from most mistakes. Uncommitted changes and untracked files deleted by git clean are not recorded anywhere, which is why those entries carry a warning.

When you must overwrite a remote branch after rewriting history, use git push --force-with-lease rather than --force: it refuses to push if the remote has commits you have not seen, so you cannot silently delete a colleague's work. Placeholders filled in on this page are validated — branch and tag names follow the rules of git check-ref-format (no spaces, no .., no leading -, no ~ ^ : ? * [ \, no .lock suffix) — and any value with special characters is wrapped in single quotes so it is passed to Git as one argument.

Limitations

The catalog is curated (about 60 tasks) rather than a full Git reference; see git help <command> for every option.
Commands target Git 2.23 or newer (git switch, git restore); git init -b needs 2.28+.
Shell quoting follows POSIX shells (bash, zsh). In Windows cmd.exe, use double quotes instead of single quotes.
The tool never runs commands; it only shows them.

Frequently asked questions

How do I undo the last commit but keep my changes?

Run git reset --soft HEAD~1 to keep the changes staged, or git reset HEAD~1 to keep them unstaged. If the commit was already pushed to a shared branch, use git revert <commit> instead.

What is the difference between git reset and git revert?

git reset moves the branch pointer backwards, removing commits from the branch history. git revert creates a new commit that undoes an earlier one, leaving history intact — the safe choice for commits others already have.

Is git push --force dangerous?

Yes, on shared branches: it replaces the remote history with yours. Prefer git push --force-with-lease, which fails if someone else pushed in the meantime, and avoid force-pushing to main without agreement.

Can I recover a deleted branch?

Usually. git branch -D prints the commit hash it deleted, and git reflog lists recent HEAD positions. Recreate the branch with git branch <branch> <commit>.

Why is my branch name rejected?

Git reference names cannot contain spaces, .., ~, ^, :, ?, *, [, backslashes or control characters, cannot start with - or ., and cannot end with /, . or .lock. Use hyphens or slashes instead, e.g. feature/new-login.

Set your name and email

Create a new repository

Clone a repository

Clone only the latest commit (shallow clone)

Set the default branch name for new repositories

Create a new branch and switch to it

Switch to an existing branch

List local and remote branches

Rename the current branch

Rename another branch

Delete a local branch

Delete a remote branch

Create a branch from a specific commit

Stage all changes and commit

Stage only part of a file

Change the last commit message

Add forgotten files to the last commit

Create an empty commit (e.g. to re-trigger CI)

Unstage a file (keep the changes)

Discard local changes to a file

Undo the last commit but keep the changes staged

Undo the last commit and unstage its changes

Delete the last commit and its changes

Undo a pushed commit safely (revert)

Make a local branch match the remote exactly

Restore a file from an older commit

Show a compact history graph

Show the history of a file

See who last changed each line

Search commit messages or code changes

Show staged and unstaged changes

See commits on one branch that are not on another

Find the commit that introduced a bug

Show configured remotes

Add a remote

Change a remote's URL (e.g. HTTPS to SSH)

Push a new branch and set its upstream

Fetch and remove deleted remote branches

Pull with rebase instead of merge

Force-push safely after rewriting history

Stash changes with a message

List and re-apply stashes

Delete a stash

Merge a branch into the current branch

Rebase a feature branch onto the latest main

Squash the last N commits into one

Abort a merge or rebase in progress

Copy a commit from another branch

Resolve a conflict by taking one side

Create and push an annotated tag

List tags

Delete a tag locally and on the remote

Remove untracked files and directories

Find and delete branches already merged

Stop tracking a file but keep it locally

Recover a lost commit with the reflog

Restore a deleted branch

Undo a reset, rebase or amend

Recover a dropped stash