Git Command Generator

Search and copy git commands — filter by category, find by keyword.

Initialize repoSetup

Create a new empty Git repository in the current directory.

git init

Clone repositorySetup

Download a remote repository to a local directory.

git clone <url>

Shallow cloneSetup

Clone with only the latest commit — much faster for large repos.

git clone --depth 1 <url>

Set global usernameSetup

Set the name that will appear in all your commits.

git config --global user.name "Your Name"

Set global emailSetup

Set the email that will appear in all your commits.

git config --global user.email "you@example.com"

List configSetup

Show all current Git configuration settings.

git config --list

Set default editorSetup

Change the editor used for commit messages (e.g., VS Code).

git config --global core.editor "code --wait"

List branchesBranches

Show all local branches. Add -a to include remote branches.

git branch

List all branchesBranches

Show local and remote tracking branches.

git branch -a

Create branchBranches

Create a new branch without switching to it.

git branch <branch-name>

Switch branchBranches

Switch to an existing branch.

git switch <branch-name>

Create & switch branchBranches

Create a new branch and switch to it in one step.

git switch -c <branch-name>

Rename branchBranches

Rename the current branch.

git branch -m <new-name>

Delete merged branchBranches

Delete a branch that has already been merged.

git branch -d <branch-name>

Force delete branchBranchesCaution

Force-delete a branch even if it has unmerged changes.

Permanently deletes local changes on the branch if unmerged.

git branch -D <branch-name>

Merge branchBranches

Merge another branch into the current branch.

git merge <branch-name>

Merge (no fast-forward)Branches

Merge with a merge commit even if fast-forward is possible — preserves branch history.

git merge --no-ff <branch-name>

Rebase onto branchBranchesCaution

Replay your commits on top of another branch for a linear history.

Rewrites commit history. Never rebase shared/published branches.

git rebase <branch-name>

Interactive rebaseBranchesCaution

Squash, reorder, or edit the last N commits interactively.

Rewrites commit history. Avoid on branches others have pulled.

git rebase -i HEAD~<n>

Show statusStaging

Show the working tree status — modified, staged, and untracked files.

git status

Stage all changesStaging

Stage all modified and new files for the next commit.

git add .

Stage a fileStaging

Stage a specific file for the next commit.

git add <file>

Stage interactively (patch)Staging

Interactively select hunks within files to stage — great for partial commits.

git add -p

Show unstaged diffStaging

Show changes in the working tree that are not yet staged.

git diff

Show staged diffStaging

Show changes that are staged and ready to commit.

git diff --staged

Discard file changesStagingCaution

Discard unstaged changes in a file, restoring it to the last commit.

Permanently discards uncommitted changes in that file.

git restore <file>

Unstage a fileStaging

Remove a file from the staging area without discarding its changes.

git restore --staged <file>

Commit staged changesCommits

Create a commit with a message from all staged changes.

git commit -m "your message"

Stage & commit tracked filesCommits

Stage all changes to tracked files and commit in one step.

git commit -am "your message"

Amend last commit messageCommitsCaution

Change the message of the most recent commit.

Rewrites the last commit. Don't amend commits already pushed.

git commit --amend

Amend last commit (keep message)CommitsCaution

Add staged changes to the last commit without changing its message.

Rewrites the last commit. Don't amend commits already pushed.

git commit --amend --no-edit

Add remote originRemote

Connect the local repo to a remote repository URL.

git remote add origin <url>

List remotesRemote

Show all configured remote connections and their URLs.

git remote -v

Fetch from remoteRemote

Download changes from remote without merging into local branches.

git fetch

Pull changesRemote

Fetch and merge changes from the remote tracking branch.

git pull

Pull with rebaseRemote

Fetch remote changes and rebase your local commits on top — keeps history linear.

git pull --rebase

Push to remoteRemote

Upload local commits to the remote branch.

git push origin <branch-name>

Push & set upstreamRemote

Push and set the remote as the default tracking branch for future pulls.

git push -u origin <branch-name>

Force push (safe)RemoteCaution

Force push only if nobody else has pushed since your last fetch — safer than --force.

Still overwrites remote history. Only use on your own feature branches.

git push --force-with-lease

Revert a commitUndo

Create a new commit that undoes the changes of a previous commit — safe for shared branches.

git revert <commit-hash>

Reset (soft) — undo commit, keep stagedUndoCaution

Move HEAD back one commit, keeping changes staged. Use to re-commit with a different message.

Rewrites history. Don't use on pushed commits.

git reset --soft HEAD~1

Reset (mixed) — undo commit, keep filesUndoCaution

Move HEAD back one commit and unstage changes, but keep your file edits.

Rewrites history. Don't use on pushed commits.

git reset HEAD~1

Reset (hard) — discard everythingUndoCaution

Move HEAD back one commit and permanently discard all changes.

DESTRUCTIVE — permanently deletes uncommitted changes and the last commit.

git reset --hard HEAD~1

Remove untracked filesUndoCaution

Delete untracked files and directories from the working tree.

DESTRUCTIVE — permanently deletes files not tracked by Git.

git clean -fd

Show commit logHistory

List commits with author, date, and full message.

git log

Show compact logHistory

Show each commit on a single line — short hash and subject.

git log --oneline

Show branch graphHistory

Show commit history as a visual ASCII graph with all branches.

git log --oneline --graph --all

Show a commitHistory

Display the diff and metadata for a specific commit.

git show <commit-hash>

Blame a fileHistory

Show which commit and author last modified each line of a file.

git blame <file>

File historyHistory

Show the commit history for a specific file.

git log --follow -p <file>

Diff between commitsHistory

Show differences between two commits or branches.

git diff <commit-a>..<commit-b>

List tagsTags

Show all tags in the repository.

git tag

Create lightweight tagTags

Create a lightweight tag pointing to the current commit.

git tag <tag-name>

Create annotated tagTags

Create an annotated tag with a message — recommended for releases.

git tag -a <tag-name> -m "Release message"

Push all tagsTags

Push all local tags to the remote.

git push origin --tags

Delete local tagTags

Remove a tag from the local repository.

git tag -d <tag-name>

Delete remote tagTags

Remove a tag that was already pushed to the remote.

git push origin --delete <tag-name>

Stash changesStash

Save uncommitted changes to a temporary shelf so you can switch branches.

git stash

Stash with messageStash

Stash changes with a descriptive name for easier identification later.

git stash push -m "stash description"

Pop latest stashStash

Apply the most recent stash and remove it from the stash list.

git stash pop

List stashesStash

Show all stashed changes.

git stash list

Apply stash (keep it)Stash

Apply a specific stash without removing it from the list.

git stash apply stash@{<n>}

Drop a stashStash

Remove a specific stash entry without applying it.

git stash drop stash@{<n>}

Cherry-pick commitAdvanced

Apply changes from a specific commit onto the current branch.

git cherry-pick <commit-hash>

Show reflogAdvanced

Show a log of all HEAD movements — useful for recovering 'lost' commits after reset.

git reflog

Start bisectAdvanced

Begin a binary search to find which commit introduced a bug.

git bisect start

Contribution summaryAdvanced

Show commit counts grouped by author — useful for changelogs.

git shortlog -sn

Add worktreeAdvanced

Check out a branch into a separate directory — work on two branches simultaneously.

git worktree add ../<dir> <branch-name>

Add submoduleAdvanced

Include another Git repository as a subdirectory of your project.

git submodule add <url> <path>

Archive repositoryAdvanced

Create a zip/tar archive of the repo at a specific commit without .git history.

git archive --format=zip HEAD > repo.zip

List available hooksAdvanced

Show the hooks available in the .git/hooks directory.

ls .git/hooks

71 commands

About this tool

The Git Command Generator is a searchable reference for 60+ git commands organized by category — Setup, Branches, Staging, Commits, Remote, Undo, History, Tags, Stash, and Advanced. Search by name or keyword to find the exact command, copy it with one click, and see warning badges on destructive commands that rewrite history.

When to use it

→Quickly finding the right git syntax without leaving the browser
→Learning git commands beyond the basics (reflog, bisect, worktree)
→Checking the correct flags for destructive operations before running them
→Onboarding new developers to git workflows with a visual reference

Tips

◆Commands marked with a Caution badge rewrite history — never use them on branches others have already pulled.
◆Search by concept, not just command name: try 'undo', 'linear', or 'recover' to find commands by what they do.
◆Your recently copied commands are saved in localStorage for quick re-access.

Frequently asked questions

What is the difference between git reset and git revert?

git revert creates a new commit that undoes a previous commit — it's safe to use on shared branches because it doesn't rewrite history. git reset moves the HEAD pointer backward, effectively removing commits from the history — this rewrites history and is destructive. Only use git reset on commits that haven't been pushed to a shared branch.

When should I use git rebase instead of git merge?

Use rebase when you want a linear, clean commit history — your commits are replayed on top of the target branch as if they were written there. Use merge when you want to preserve the true divergence history with a merge commit. The golden rule: never rebase branches that others have already pulled from, as it rewrites the commit hashes they reference.

What does git stash do and when should I use it?

git stash temporarily saves your uncommitted changes (both staged and unstaged) to a stack, leaving your working directory clean. Use it when you need to quickly switch branches or pull changes without committing half-finished work. Run git stash pop to restore the most recent stash, or git stash list to see all stored stashes.

How do I recover commits after a git reset --hard?

Use git reflog — it logs every position HEAD has been at, even after hard resets. Find the commit hash you want to recover in the reflog output, then run git checkout <hash> to inspect it, or git reset --hard <hash> to restore your branch to that state. The reflog is local and expires after 90 days by default.