Initial Commit

Learn and use Git visually (for free)

Git becomes simple when you can actually see what's happening.

For explorers For learners For developers

git-sim

Initial Commit Devlands

created with git-sim

Start here

Are you exploring, learning, or developing with Git?

Pick your path below. Every path is visual and interactive.

Explore127 commands

The Animated Git Cheat Sheet

Stuck on a Git command or need a quick refresher? We used git-sim to build an animated cheat sheet with every Git command you could possibly need.

You can even customize it by hand-picking the exact Git commands to include.

Open the cheat sheet

Create a repository Safe

$ git init Start a project Delete a file from the repository Caution

$ git rm <file> Manage files Delete untracked files Destructive

$ git clean -f Manage files Copy a repository Safe

$ git clone <url> Start a project Abort a conflicted merge Caution

$ git merge --abort Merge Delete untracked and ignored files Destructive

$ git clean -fdx Manage files Copy only the latest commits Safe

git-sim drawing of git clone --depth 1 <url>

$ git clone --depth 1 <url> Start a project Rebase your branch onto another Caution

$ git rebase <branch> Rebase and cherry-pick Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches Clone and check out a branch Safe

git-sim drawing of git clone -b <branch> <url>

$ git clone -b <branch> <url> Start a project Edit, squash or reorder your commits Caution

$ git rebase -i <base> Rebase and cherry-pick Delete a remote branch Destructive

git-sim drawing of git push origin --delete <branch>

$ git push origin --delete <branch> Fetch, pull and push Set your name for commits Safe

git-sim drawing of git config --global user.name "<name>"

$ git config --global user.name "<name>" Configure Git Move part of a branch to a new base Caution

git-sim drawing of git rebase --onto <new-base> <old-base>

$ git rebase --onto <new-base> <old-base> Rebase and cherry-pick Delete a remote tag Destructive

git-sim drawing of git push origin --delete <tag>

$ git push origin --delete <tag> Tags Set your email for commits Safe

git-sim drawing of git config --global user.email "<email>"

$ git config --global user.email "<email>" Configure Git Skip the conflicting commit in a rebase Caution

$ git rebase --skip Rebase and cherry-pick Delete every stash Destructive

$ git stash clear Stash Name the first branch main Safe

git-sim drawing of git config --global init.defaultBranch main

$ git config --global init.defaultBranch main Configure Git Abort a rebase Caution

$ git rebase --abort Rebase and cherry-pick Discard changes to a file Destructive

$ git restore <file> Undo and recover Choose Git's text editor Safe

git-sim drawing of git config --global core.editor "code --wait"

$ git config --global core.editor "code --wait" Configure Git Remove a remote Caution

git-sim drawing of git remote remove <name>

$ git remote remove <name> Remotes Discard all your changes Destructive

$ git restore . Undo and recover See all your settings Safe

$ git config --list Configure Git Pull and rebase, without a merge commit Caution

$ git pull --rebase Fetch, pull and push Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Make a shortcut for a command Safe

git-sim drawing of git config --global alias.<name> <command>

$ git config --global alias.<name> <command> Configure Git Force-push safely Caution

git-sim drawing of git push --force-with-lease

$ git push --force-with-lease Fetch, pull and push Throw away commits and changes Destructive

git-sim drawing of git reset --hard <commit>

$ git reset --hard <commit> Undo and recover Rebase instead of merge on pull Safe

git-sim drawing of git config --global pull.rebase true

$ git config --global pull.rebase true Configure Git Force-push over the remote Caution

$ git push --force Fetch, pull and push Delete untracked files Destructive

$ git clean -f Manage files Clean up deleted branches on every fetch Safe

git-sim drawing of git config --global fetch.prune true

$ git config --global fetch.prune true Configure Git Delete a tag Caution

$ git tag -d <name> Tags Delete untracked and ignored files Destructive

$ git clean -fdx Manage files Handle line endings across Windows and Mac Safe

git-sim drawing of git config --global core.autocrlf true

$ git config --global core.autocrlf true Configure Git Delete a stash Caution

$ git stash drop Stash Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches Remember your login Safe

git-sim drawing of git config --global credential.helper <helper>

$ git config --global credential.helper <helper> Configure Git Fix the last commit Caution

$ git commit --amend Undo and recover Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push See what's changed Safe

$ git status Stage and commit Undo a commit, keep its changes staged Caution

git-sim drawing of git reset --soft HEAD~1

$ git reset --soft HEAD~1 Undo and recover Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Stage files Safe

$ git add <file> Stage and commit Undo a commit, keep its changes unstaged Caution

$ git reset HEAD~1 Undo and recover Delete every stash Destructive

$ git stash clear Stash Commit your staged changes Safe

git-sim drawing of git commit -m "<message>"

$ git commit -m "<message>" Stage and commit Make your branch match the remote Caution

git-sim drawing of git reset --hard origin/<branch>

$ git reset --hard origin/<branch> Undo and recover Discard changes to a file Destructive

$ git restore <file> Undo and recover Stage and commit tracked files at once Safe

git-sim drawing of git commit -am "<message>"

$ git commit -am "<message>" Stage and commit Undo a reset Caution

git-sim drawing of git reset --hard HEAD@{1}

$ git reset --hard HEAD@{1} Undo and recover Discard all your changes Destructive

$ git restore . Undo and recover Stop tracking a file but keep it Safe

git-sim drawing of git rm --cached <file>

$ git rm --cached <file> Manage files Delete a file from the repository Caution

$ git rm <file> Manage files Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Rename or move a file Safe

$ git mv <old> <new> Manage files Abort a conflicted merge Caution

$ git merge --abort Merge Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover Find out why a file is ignored Safe

git-sim drawing of git check-ignore -v <file>

$ git check-ignore -v <file> Manage files Rebase your branch onto another Caution

$ git rebase <branch> Rebase and cherry-pick Delete untracked files Destructive

$ git clean -f Manage files View the commit history Safe

$ git log History and search Edit, squash or reorder your commits Caution

$ git rebase -i <base> Rebase and cherry-pick Delete untracked and ignored files Destructive

$ git clean -fdx Manage files View the history of every branch Safe

$ git log --all History and search Move part of a branch to a new base Caution

$ git rebase --onto <new-base> <old-base> Rebase and cherry-pick Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches See every branch as a graph Safe

git-sim drawing of git log --oneline --graph --all

$ git log --oneline --graph --all History and search Skip the conflicting commit in a rebase Caution

$ git rebase --skip Rebase and cherry-pick Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push See how a file changed, commit by commit Safe

$ git log -p <file> History and search Abort a rebase Caution

$ git rebase --abort Rebase and cherry-pick Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Follow a file's history through renames Safe

git-sim drawing of git log --follow <file>

$ git log --follow <file> History and search Remove a remote Caution

$ git remote remove <name> Remotes Delete every stash Destructive

$ git stash clear Stash Find the commit that added or removed some code Safe

$ git log -S "<text>" History and search Pull and rebase, without a merge commit Caution

$ git pull --rebase Fetch, pull and push Discard changes to a file Destructive

$ git restore <file> Undo and recover See one person's commits Safe

git-sim drawing of git log --author "<name>"

$ git log --author "<name>" History and search Force-push safely Caution

$ git push --force-with-lease Fetch, pull and push Discard all your changes Destructive

$ git restore . Undo and recover See the commits from a time range Safe

git-sim drawing of git log --since "2 weeks ago" --until "yesterday"

$ git log --since "2 weeks ago" --until "yesterday" History and search Force-push over the remote Caution

$ git push --force Fetch, pull and push Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover View a commit's data Safe

$ git show <commit> History and search Delete a tag Caution

$ git tag -d <name> Tags Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover See who changed each line Safe

$ git blame <file> History and search Delete a stash Caution

$ git stash drop Stash Delete untracked files Destructive

$ git clean -f Manage files Count commits by author Safe

$ git shortlog -sn History and search Fix the last commit Caution

$ git commit --amend Undo and recover Delete untracked and ignored files Destructive

$ git clean -fdx Manage files Name a commit after the nearest tag Safe

$ git describe History and search Undo a commit, keep its changes staged Caution

$ git reset --soft HEAD~1 Undo and recover Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches Search the code in your repository Safe

$ git grep -n "<text>" History and search Undo a commit, keep its changes unstaged Caution

$ git reset HEAD~1 Undo and recover Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push Find the commit that broke something Safe

git-sim drawing of git bisect start <bad> <good>

$ git bisect start <bad> <good> History and search Make your branch match the remote Caution

$ git reset --hard origin/<branch> Undo and recover Delete a remote tag Destructive

$ git push origin --delete <tag> Tags See unstaged changes Safe

$ git diff Compare changes Undo a reset Caution

$ git reset --hard HEAD@{1} Undo and recover Delete every stash Destructive

$ git stash clear Stash See staged changes Safe

$ git diff --staged Compare changes Delete a file from the repository Caution

$ git rm <file> Manage files Discard changes to a file Destructive

$ git restore <file> Undo and recover Compare two commits Safe

git-sim drawing of git diff <commit> <commit>

$ git diff <commit> <commit> Compare changes Abort a conflicted merge Caution

$ git merge --abort Merge Discard all your changes Destructive

$ git restore . Undo and recover Compare two branches Safe

git-sim drawing of git diff <branch>..<branch>

$ git diff <branch>..<branch> Compare changes Rebase your branch onto another Caution

$ git rebase <branch> Rebase and cherry-pick Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Summarize what changed Safe

$ git diff --stat Compare changes Edit, squash or reorder your commits Caution

$ git rebase -i <base> Rebase and cherry-pick Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover Create a branch Safe

$ git branch <name> Branches Move part of a branch to a new base Caution

$ git rebase --onto <new-base> <old-base> Rebase and cherry-pick Delete untracked files Destructive

$ git clean -f Manage files List all branches, remote ones too Safe

$ git branch -a Branches Skip the conflicting commit in a rebase Caution

$ git rebase --skip Rebase and cherry-pick Delete untracked and ignored files Destructive

$ git clean -fdx Manage files See which branches are ahead or behind Safe

$ git branch -vv Branches Abort a rebase Caution

$ git rebase --abort Rebase and cherry-pick Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches List branches that are safe to delete Safe

$ git branch --merged Branches Remove a remote Caution

$ git remote remove <name> Remotes Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push List branches with unmerged work Safe

git-sim drawing of git branch --no-merged

$ git branch --no-merged Branches Pull and rebase, without a merge commit Caution

$ git pull --rebase Fetch, pull and push Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Switch branches Safe

$ git switch <branch> Branches Force-push safely Caution

$ git push --force-with-lease Fetch, pull and push Delete every stash Destructive

$ git stash clear Stash Switch back to the previous branch Safe

$ git switch - Branches Force-push over the remote Caution

$ git push --force Fetch, pull and push Discard changes to a file Destructive

$ git restore <file> Undo and recover Check out a teammate's branch Safe

$ git switch <branch> Branches Delete a tag Caution

$ git tag -d <name> Tags Discard all your changes Destructive

$ git restore . Undo and recover Create a branch and switch to it Safe

$ git switch -c <name> Branches Delete a stash Caution

$ git stash drop Stash Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Create a branch from another commit Safe

git-sim drawing of git switch -c <name> <start>

$ git switch -c <name> <start> Branches Fix the last commit Caution

$ git commit --amend Undo and recover Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover Rename a branch Safe

git-sim drawing of git branch -m <old> <new>

$ git branch -m <old> <new> Branches Undo a commit, keep its changes staged Caution

$ git reset --soft HEAD~1 Undo and recover Delete untracked files Destructive

$ git clean -f Manage files Delete a merged branch Safe

$ git branch -d <name> Branches Undo a commit, keep its changes unstaged Caution

$ git reset HEAD~1 Undo and recover Delete untracked and ignored files Destructive

$ git clean -fdx Manage files Check out an old commit Safe

git-sim drawing of git switch --detach <commit>

$ git switch --detach <commit> Branches Make your branch match the remote Caution

$ git reset --hard origin/<branch> Undo and recover Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches Merge a branch into yours Safe

$ git merge <branch> Merge Undo a reset Caution

$ git reset --hard HEAD@{1} Undo and recover Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push Fast-forward to a branch Safe

$ git merge <branch> Merge Delete a file from the repository Caution

$ git rm <file> Manage files Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Merge with a merge commit, always Safe

git-sim drawing of git merge --no-ff <branch>

$ git merge --no-ff <branch> Merge Abort a conflicted merge Caution

$ git merge --abort Merge Delete every stash Destructive

$ git stash clear Stash Squash a branch into one commit Safe

git-sim drawing of git merge --squash <branch>

$ git merge --squash <branch> Merge Rebase your branch onto another Caution

$ git rebase <branch> Rebase and cherry-pick Discard changes to a file Destructive

$ git restore <file> Undo and recover Finish a merge after fixing conflicts Safe

$ git merge --continue Merge Edit, squash or reorder your commits Caution

$ git rebase -i <base> Rebase and cherry-pick Discard all your changes Destructive

$ git restore . Undo and recover Continue a rebase after fixing conflicts Safe

git-sim drawing of git rebase --continue

$ git rebase --continue Rebase and cherry-pick Move part of a branch to a new base Caution

$ git rebase --onto <new-base> <old-base> Rebase and cherry-pick Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Copy a commit onto your branch Safe

git-sim drawing of git cherry-pick <commit>

$ git cherry-pick <commit> Rebase and cherry-pick Skip the conflicting commit in a rebase Caution

$ git rebase --skip Rebase and cherry-pick Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover Copy a range of commits Safe

git-sim drawing of git cherry-pick <from>..<to>

$ git cherry-pick <from>..<to> Rebase and cherry-pick Abort a rebase Caution

$ git rebase --abort Rebase and cherry-pick Delete untracked files Destructive

$ git clean -f Manage files Add a remote repository Safe

git-sim drawing of git remote add <name> <url>

$ git remote add <name> <url> Remotes Remove a remote Caution

$ git remote remove <name> Remotes Delete untracked and ignored files Destructive

$ git clean -fdx Manage files List your remotes and their URLs Safe

$ git remote -v Remotes Pull and rebase, without a merge commit Caution

$ git pull --rebase Fetch, pull and push Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches See the details of a remote Safe

git-sim drawing of git remote show origin

$ git remote show origin Remotes Force-push safely Caution

$ git push --force-with-lease Fetch, pull and push Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push Change a remote's URL Safe

git-sim drawing of git remote set-url <name> <url>

$ git remote set-url <name> <url> Remotes Force-push over the remote Caution

$ git push --force Fetch, pull and push Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Rename a remote Safe

git-sim drawing of git remote rename <old> <new>

$ git remote rename <old> <new> Remotes Delete a tag Caution

$ git tag -d <name> Tags Delete every stash Destructive

$ git stash clear Stash See a remote's branches and tags without fetching Safe

$ git ls-remote Remotes Delete a stash Caution

$ git stash drop Stash Discard changes to a file Destructive

$ git restore <file> Undo and recover Link a branch to a remote branch Safe

git-sim drawing of git branch -u origin/<branch>

$ git branch -u origin/<branch> Remotes Fix the last commit Caution

$ git commit --amend Undo and recover Discard all your changes Destructive

$ git restore . Undo and recover Download new commits without merging Safe

$ git fetch Fetch, pull and push Undo a commit, keep its changes staged Caution

$ git reset --soft HEAD~1 Undo and recover Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Fetch from every remote Safe

$ git fetch --all Fetch, pull and push Undo a commit, keep its changes unstaged Caution

$ git reset HEAD~1 Undo and recover Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover Clean up deleted remote branches Safe

$ git fetch --prune Fetch, pull and push Make your branch match the remote Caution

$ git reset --hard origin/<branch> Undo and recover Delete untracked files Destructive

$ git clean -f Manage files Pull and merge remote changes Safe

$ git pull Fetch, pull and push Undo a reset Caution

$ git reset --hard HEAD@{1} Undo and recover Delete untracked and ignored files Destructive

$ git clean -fdx Manage files Pull a specific remote branch Safe

git-sim drawing of git pull origin <branch>

$ git pull origin <branch> Fetch, pull and push Delete a file from the repository Caution

$ git rm <file> Manage files Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches Push your commits Safe

$ git push Fetch, pull and push Abort a conflicted merge Caution

$ git merge --abort Merge Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push Publish a new branch Safe

git-sim drawing of git push -u origin <branch>

$ git push -u origin <branch> Fetch, pull and push Rebase your branch onto another Caution

$ git rebase <branch> Rebase and cherry-pick Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Tag a commit as a release Safe

$ git tag <name> Tags Edit, squash or reorder your commits Caution

$ git rebase -i <base> Rebase and cherry-pick Delete every stash Destructive

$ git stash clear Stash Tag a release with a message Safe

git-sim drawing of git tag -a <name> -m "<message>"

$ git tag -a <name> -m "<message>" Tags Move part of a branch to a new base Caution

$ git rebase --onto <new-base> <old-base> Rebase and cherry-pick Discard changes to a file Destructive

$ git restore <file> Undo and recover List your tags Safe

$ git tag -l Tags Skip the conflicting commit in a rebase Caution

$ git rebase --skip Rebase and cherry-pick Discard all your changes Destructive

$ git restore . Undo and recover Push one tag Safe

git-sim drawing of git push origin <tag>

$ git push origin <tag> Tags Abort a rebase Caution

$ git rebase --abort Rebase and cherry-pick Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Push your tags Safe

$ git push --tags Tags Remove a remote Caution

$ git remote remove <name> Remotes Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover Stash your changes Safe

$ git stash Stash Pull and rebase, without a merge commit Caution

$ git pull --rebase Fetch, pull and push Delete untracked files Destructive

$ git clean -f Manage files Stash untracked files too Safe

$ git stash -u Stash Force-push safely Caution

$ git push --force-with-lease Fetch, pull and push Delete untracked and ignored files Destructive

$ git clean -fdx Manage files Stash with a description Safe

git-sim drawing of git stash push -m "<message>"

$ git stash push -m "<message>" Stash Force-push over the remote Caution

$ git push --force Fetch, pull and push Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches Stash only some files Safe

git-sim drawing of git stash push <file>

$ git stash push <file> Stash Delete a tag Caution

$ git tag -d <name> Tags Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push List your stashes Safe

$ git stash list Stash Delete a stash Caution

$ git stash drop Stash Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Apply and remove the latest stash Safe

$ git stash pop Stash Fix the last commit Caution

$ git commit --amend Undo and recover Delete every stash Destructive

$ git stash clear Stash Apply a stash but keep it Safe

$ git stash apply Stash Undo a commit, keep its changes staged Caution

$ git reset --soft HEAD~1 Undo and recover Discard changes to a file Destructive

$ git restore <file> Undo and recover See what's in a stash Safe

$ git stash show -p Stash Undo a commit, keep its changes unstaged Caution

$ git reset HEAD~1 Undo and recover Discard all your changes Destructive

$ git restore . Undo and recover Turn a stash into a branch Safe

git-sim drawing of git stash branch <name>

$ git stash branch <name> Stash Make your branch match the remote Caution

$ git reset --hard origin/<branch> Undo and recover Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover Work on two branches at once Safe

git-sim drawing of git worktree add <folder> <branch>

$ git worktree add <folder> <branch> Worktrees Undo a reset Caution

$ git reset --hard HEAD@{1} Undo and recover Throw away commits and changes Destructive

$ git reset --hard <commit> Undo and recover List your worktrees Safe

$ git worktree list Worktrees Delete a file from the repository Caution

$ git rm <file> Manage files Delete untracked files Destructive

$ git clean -f Manage files Forget worktrees you deleted by hand Safe

$ git worktree prune Worktrees Abort a conflicted merge Caution

$ git merge --abort Merge Delete untracked and ignored files Destructive

$ git clean -fdx Manage files Unstage a file Safe

git-sim drawing of git restore --staged <file>

$ git restore --staged <file> Undo and recover Rebase your branch onto another Caution

$ git rebase <branch> Rebase and cherry-pick Force-delete an unmerged branch Destructive

$ git branch -D <name> Branches Restore a file from an older commit Safe

git-sim drawing of git restore --source <commit> <file>

$ git restore --source <commit> <file> Undo and recover Edit, squash or reorder your commits Caution

$ git rebase -i <base> Rebase and cherry-pick Delete a remote branch Destructive

$ git push origin --delete <branch> Fetch, pull and push Undo a pushed commit Safe

$ git revert <commit> Undo and recover Move part of a branch to a new base Caution

$ git rebase --onto <new-base> <old-base> Rebase and cherry-pick Delete a remote tag Destructive

$ git push origin --delete <tag> Tags Undo a pushed merge Safe

git-sim drawing of git revert -m 1 <merge>

$ git revert -m 1 <merge> Undo and recover Skip the conflicting commit in a rebase Caution

$ git rebase --skip Rebase and cherry-pick Delete every stash Destructive

$ git stash clear Stash Undo several commits as one Safe

git-sim drawing of git revert --no-commit <from>..<to>

$ git revert --no-commit <from>..<to> Undo and recover Abort a rebase Caution

$ git rebase --abort Rebase and cherry-pick Discard changes to a file Destructive

$ git restore <file> Undo and recover Find a lost commit Safe

$ git reflog Undo and recover Remove a remote Caution

$ git remote remove <name> Remotes Discard all your changes Destructive

$ git restore . Undo and recover Restore a deleted branch Safe

git-sim drawing of git branch <name> <hash>

$ git branch <name> <hash> Undo and recover Pull and rebase, without a merge commit Caution

$ git pull --rebase Fetch, pull and push Discard all your changes, older Git Destructive

$ git checkout -- . Undo and recover

LearnGit lessons

Visual Git lessons based on a real-world analogy that makes sense

Interactive Git lessons you work through in your browser, one small step at a time.

Your Git repo becomes a scrapbook, commits become pages you glue in, and code files become special treasures. Fill up your scrapbook while learning how to use Git!

Start level 1

The scrapbook: the repository as a binder of pages, the working directory as a table with a staging area on it, and origin as the shared copy

Developfree & open source

git-sim: the visual layer for Git in your own repos

Try git-sim pip install git-sim

git-sim's interactive viewer playing git rebase in the browser

01 Simulate any Git command before it runs, as an interactive graph you can step through TerminalWebVS CodeJupyterVim / Neovim / EmacsGitHub PRs Open the git-sim web viewer

A git-sim live recording of a repository: each checkout, commit and merge kept as a step you can replay

02 Track your repo live while recording every Git operation (human or agentic) as a visual command sequence you can replay WebVS Code Try git-sim live mode

agent · wants to run

$ git reset --hard HEAD~2
DESTRUCTIVE git-sim pre-flight
Moves main from 8c02d5b to 96c4fc2 (hard reset).
Would lose:
  2 commits removed from branch main
  staged changes in README.md (NOT recoverable)
  unstaged changes in app.py (NOT recoverable)
Recover: commits stay in the reflog ~90 days
Allow this command? [y/N]

03 Catch and review potentially destructive Git commands from AI agents in real-time, before they harm your work Claude CodeGitHub CopilotCursorCodexGemini CLI+ any MCP agent Check out git-sim pre-flight

04 Share any git-sim output as a link, an embed, an image, a video, or a social post Shareable linkHTML embedHTML pagePNGSVGMP4Social post Share and embed custom Git simulations