Git

Basics

Basic git commands

15commands

Commits

Commit operations

13commands

Branches

Branch management

18commands

Stash

Stash operations

Rebase

Rebase operations

Remote

Remote repository operations

History

History and logs

16commands

Reflog

Reference log recovery

5commands

Bisect

Binary search for bugs

Worktree

Multiple working trees

Submodules

Submodule management

Cleanup

Cleanup operations

Config

Git configuration

10commands

Maintenance

Repository maintenance

7commands

Sparse Checkout

Partial repository checkout

Advanced

Advanced git operations

Install Git (macOS)

$ brew install git

Install Git using Homebrew on macOS

Configure user name

$ git config --global user.name 'Your Name'

Set your name for Git commits globally

Configure user email

$ git config --global user.email 'you@example.com'

Set your email for Git commits globally

Initialize repository

$ git init

Create a new Git repository in the current directory

Initialize repository

$ git init

Create a new Git repository in the current directory.

Clone repository

$ git clone <url>

Clone a remote repository to your local machine.

Clone with depth

$ git clone --depth 1 <url>

Shallow clone with only the latest commit for faster downloads.

Clone specific branch

$ git clone -b <branch> <url>

Clone a specific branch.

Status

$ git status

Show working tree status.

Short status

$ git status -s

Show status in short format.

Add all changes

$ git add .

Stage all changes for commit.

Add specific file

$ git add <file>

Stage specific file for commit.

Add interactively

$ git add -p

Interactively stage hunks of changes.

Commit

$ git commit -m "message"

Commit staged changes with message.

Commit all tracked changes

$ git commit -am "message"

Stage and commit all tracked files.

Pull

$ git pull

Fetch and merge from remote.

Pull with rebase

$ git pull --rebase

Fetch and rebase local commits on top.

Push

$ git push

Push commits to remote.

Fetch all

$ git fetch --all

Fetch from all remotes.

Undo last commit (keep changes)

$ git reset --soft HEAD~1

Undo last commit but keep changes staged.

Undo last commit (unstage changes)

$ git reset HEAD~1

Undo last commit and unstage changes.

Undo last commit (discard changes)

$ git reset --hard HEAD~1

Completely remove last commit and changes.

Amend last commit message

$ git commit --amend -m "new message"

Change message of last commit.

Amend without changing message

$ git commit --amend --no-edit

Add staged changes to last commit.

Cherry-pick commit

$ git cherry-pick <commit-hash>

Apply a specific commit from another branch.

Cherry-pick without commit

$ git cherry-pick -n <commit-hash>

Apply changes without committing.

Cherry-pick range

$ git cherry-pick <start>^..<end>

Apply a range of commits.

View file at commit

$ git show <commit>:<file>

Display file contents at specific commit.

Revert commit

$ git revert <commit>

Create new commit that undoes changes.

Commit with signature

$ git commit -S -m "message"

Create GPG-signed commit.

Empty commit

$ git commit --allow-empty -m "trigger CI"

Create commit with no changes.

Fixup commit

$ git commit --fixup <commit>

Create fixup commit for autosquash.

Stash changes

$ git stash

Stash uncommitted changes.

Stash with message

$ git stash push -m "WIP: feature"

Stash with descriptive message.

Stash including untracked

$ git stash -u

Stash including untracked files.

Stash specific files

$ git stash push <file1> <file2>

Stash only specific files.

List stashes

$ git stash list

Show all stashed changes.

Show stash contents

$ git stash show -p stash@{0}

Show diff of stash contents.

Apply stash

$ git stash apply

Apply latest stash, keep in list.

Apply specific stash

$ git stash apply stash@{2}

Apply specific stash by index.

Pop stash

$ git stash pop

Apply and remove latest stash.

Drop stash

$ git stash drop stash@{0}

Remove specific stash.

Clear all stashes

$ git stash clear

Remove all stashes.

Create branch from stash

$ git stash branch <branch> stash@{0}

Create branch and apply stash.

Rebase onto branch

$ git rebase <branch>

Rebase current branch onto another.

Interactive rebase

$ git rebase -i HEAD~5

Interactively rewrite last 5 commits.

Interactive rebase from root

$ git rebase -i --root

Rebase entire history from first commit.

Rebase with autosquash

$ git rebase -i --autosquash HEAD~5

Auto-reorder fixup/squash commits.

Continue rebase

$ git rebase --continue

Continue after resolving conflicts.

Abort rebase

$ git rebase --abort

Cancel rebase and restore state.

Skip commit during rebase

$ git rebase --skip

Skip current commit and continue.

Rebase onto specific commit

$ git rebase --onto <newbase> <oldbase> <branch>

Transplant commits to new base.

List remotes

$ git remote -v

Show remote repositories with URLs.

Add remote

$ git remote add <name> <url>

Add a new remote repository.

Remove remote

$ git remote remove <name>

Remove a remote.

Rename remote

$ git remote rename <old> <new>

Rename a remote.

Change remote URL

$ git remote set-url origin <new-url>

Update remote repository URL.

Push with upstream

$ git push -u origin <branch>

Push and set upstream tracking.

Force push safely

$ git push --force-with-lease

Force push, abort if remote changed.

Delete remote branch

$ git push origin --delete <branch>

Delete branch from remote.

Prune remote branches

$ git remote prune origin

Remove stale remote tracking branches.

Fetch and prune

$ git fetch --prune

Fetch and remove deleted branches.

Push tags

$ git push --tags

Push all tags to remote.

Sync fork with upstream

$ git fetch upstream && git rebase upstream/main

Update fork with upstream changes.

View reflog

$ git reflog

Show reference log (all HEAD changes).

Reflog for branch

$ git reflog <branch>

Show reflog for specific branch.

Recover deleted branch

$ git checkout -b <branch> <reflog-entry>

Restore branch from reflog entry.

Recover lost commit

$ git cherry-pick <reflog-hash>

Recover commit from reflog.

Reset to reflog entry

$ git reset --hard HEAD@{5}

Reset to previous HEAD state.

Start bisect

$ git bisect start

Begin binary search for bug.

Mark bad commit

$ git bisect bad

Mark current commit as bad.

Mark good commit

$ git bisect good <commit>

Mark commit as good.

Reset bisect

$ git bisect reset

End bisect and return to original HEAD.

Bisect with script

$ git bisect run <script>

Automate bisect with test script.

Skip bisect commit

$ git bisect skip

Skip untestable commit.

List worktrees

$ git worktree list

Show all linked working trees.

Add worktree

$ git worktree add <path> <branch>

Create new working tree for branch.

Add worktree with new branch

$ git worktree add -b <branch> <path>

Create worktree with new branch.

Remove worktree

$ git worktree remove <path>

Remove a linked working tree.

Prune worktrees

$ git worktree prune

Clean up stale worktree information.

Lock worktree

$ git worktree lock <path>

Prevent worktree from being removed.

Unlock worktree

$ git worktree unlock <path>

Allow worktree to be removed.

Move worktree

$ git worktree move <path> <new-path>

Move worktree to new location.

Add submodule

$ git submodule add <url> <path>

Add a git submodule.

Initialize submodules

$ git submodule init

Initialize submodule configuration.

Update submodules

$ git submodule update --init --recursive

Clone and checkout submodules.

Update submodules to latest

$ git submodule update --remote

Update submodules to latest remote.

List submodules

$ git submodule status

Show submodule status.

Clone with submodules

$ git clone --recurse-submodules <url>

Clone repo including submodules.

Remove submodule

$ git submodule deinit <path> && git rm <path>

Remove a submodule.

Execute in all submodules

$ git submodule foreach 'git pull'

Run command in each submodule.

List tags

$ git tag

List all tags.

Create lightweight tag

$ git tag <tagname>

Create a simple tag.

Create annotated tag

$ git tag -a <tagname> -m "message"

Create tag with message.

Create signed tag

$ git tag -s <tagname> -m "message"

Create GPG-signed tag.

Tag specific commit

$ git tag <tagname> <commit>

Tag a specific commit.

Delete local tag

$ git tag -d <tagname>

Remove a local tag.

Delete remote tag

$ git push origin :refs/tags/<tagname>

Remove tag from remote.

Push single tag

$ git push origin <tagname>

Push specific tag to remote.

Checkout tag

$ git checkout tags/<tagname>

Checkout a specific tag.

Clean dry run

$ git clean -n -d

Preview files to be removed.

Clean untracked files

$ git clean -f -d

Remove untracked files and directories.

Clean including ignored

$ git clean -f -d -x

Remove untracked and ignored files.

Discard file changes

$ git checkout -- <file>

Discard changes to a file.

Restore file (modern)

$ git restore <file>

Discard changes (Git 2.23+).

Unstage file

$ git restore --staged <file>

Unstage a file.

Reset to commit

$ git reset --hard <commit>

Reset HEAD, index, and working tree.

Garbage collect

$ git gc --aggressive

Optimize repository storage.

Set user name

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

Set global git username.

Set user email

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

Set global git email.

Set default editor

$ git config --global core.editor vim

Set default text editor.

Set default branch

$ git config --global init.defaultBranch main

Set default branch for new repos.

Enable autostash on rebase

$ git config --global rebase.autoStash true

Auto-stash before rebase.

Set pull to rebase

$ git config --global pull.rebase true

Default pull to rebase instead of merge.

List all config

$ git config --list

Show all git configuration.

Create alias

$ git config --global alias.co checkout

Create git command alias.

Set GPG signing key

$ git config --global user.signingkey <key-id>

Configure GPG key for signing.

Enable auto signing

$ git config --global commit.gpgsign true

Auto-sign all commits with GPG.

Start background maintenance

$ git maintenance start

Enable automatic background maintenance.

Stop background maintenance

$ git maintenance stop

Disable automatic background maintenance.

Run maintenance tasks

$ git maintenance run

Manually run repository maintenance tasks.

Register for maintenance

$ git maintenance register

Unregister from maintenance

$ git maintenance unregister

Unregister repo from background maintenance.

Optimize repository pack

$ git repack -a -d --depth=250 --window=250

Aggressive repository optimization and compression.

Prune unreachable objects

$ git prune

Remove unreachable objects from database.

Initialize sparse checkout

$ git sparse-checkout init

Enable sparse checkout mode.

Set sparse checkout paths

$ git sparse-checkout set <paths>

Define which paths to include in checkout.

Add sparse checkout paths

$ git sparse-checkout add <paths>

Add additional paths to sparse checkout.

List sparse checkout patterns

$ git sparse-checkout list

Show current sparse checkout patterns.

Reapply sparse checkout

$ git sparse-checkout reapply

Reapply sparse checkout rules to working tree.

Disable sparse checkout

$ git sparse-checkout disable

Disable sparse checkout and populate all files.

Switch to detached HEAD

$ git switch --detach <commit>

Switch to commit in detached HEAD state.

Restore from specific commit

$ git restore --source=<commit> <file>

Restore file from specific commit.

Compare commit ranges

$ git range-diff <base> <branch1> <branch2>

Compare two commit ranges for rebasing.

Create bundle file

$ git bundle create <file> <refs>

Create bundle file for offline transport.

Discussion

Loading comments...

Git

Essential version control commands for branching, committing, merging, and managing your codebase history with confidence.

169 commands

Browse by Topic

Getting Started

Quick setup and installation

Basics

Basic git commands

15commands

Commits

Commit operations

13commands

Branches

Branch management

18commands

Stash

Stash operations

Rebase

Rebase operations

Remote

Remote repository operations

History

History and logs

16commands

Reflog

Reference log recovery

5commands

Bisect

Binary search for bugs

Worktree

Multiple working trees

Submodules

Submodule management

Cleanup

Cleanup operations

Config

Git configuration

10commands

Maintenance

Repository maintenance

7commands

Sparse Checkout

Partial repository checkout

Advanced

Advanced git operations