简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Learn Git Branching?
Learn Git Branching is a browser-based interactive simulator that teaches Git branching and history manipulation by letting you run real Git commands against a visualized repository. Instead of reading about how merge, rebase, cherry-pick, or reset behave, you type the commands and watch the commit graph redraw itself after each step. The page itself states that it simulates a git repository in your browser and requires JavaScript to run.
It is best understood as a practice environment, not a reference manual. The core loop is: read a short goal, enter commands in a simulated terminal, and see the resulting graph. Because everything happens in the browser, a mistake costs nothing — no local repo, no remote, no cleanup.
Who it suits
- Git beginners who understand
commitandbranchbut find merge conflicts and history rewriting abstract. - Intermediate users who use Git daily but avoid
rebase -i,rebase --onto, or relative refs likeHEAD~2because the mental model is fuzzy. - Teachers and study groups who want a shared, zero-setup exercise that works on any machine with a browser.
It is less useful if you already reason confidently about commit graphs, or if you need help with hosting, CI, or repository administration — those are outside a branching simulator's scope.
What you actually practice
The exercises are organized as levels, so you build up rather than jump straight into advanced rewriting. Typical ground covered:
- Creating, moving, and deleting branches; switching with
checkoutorswitch. - Merging versus rebasing the same set of commits, and seeing why the resulting graphs differ.
- Moving commits around with
cherry-pick. - Referring to commits by relative position and by hash.
- Undoing and repositioning work with
resetandrevert.
Trade-offs to weigh
| Strength | Limitation |
|---|---|
| Instant visual feedback on the commit graph | Simplified repository — no remotes, hooks, submodules, or real file conflicts |
| No installation or account needed | Requires JavaScript; the app will not load without it |
| Safe place to make destructive-looking mistakes | Graph intuition does not transfer automatically to merge-conflict resolution in real files |
A practical next step: open Learn Git Branching and work the introductory sequence in one sitting, then immediately repeat the same operations in a scratch repository on your own machine (git init in a throwaway folder). The gap you notice between the two — usually around conflict handling or working-tree state — tells you what to study next. For a text reference to pair with it, the official Git documentation covers the same commands in prose.
How does the interactive visualization help me understand Git branching?
Learn Git Branching turns Git branching into something you manipulate directly rather than read about. Instead of typing commands into a real repo and guessing what happened, you issue each command against a simulated repository and watch the commit graph redraw itself after every step. The branch labels, HEAD pointer, and new commits move visibly, so the cause-and-effect of commands like branch, checkout, merge, and rebase becomes concrete.
What the visualization actually shows you
- The commit history as a graph, with branches as labeled pointers that slide forward as you commit.
- Where
HEADsits, which explains why some commands act on your current branch and others do not. - How merges create a new commit joining two lines of history, versus how rebase replays commits onto a new base and rewrites their positions.
- Detached HEAD states, which are the usual source of confusion when you check out a commit hash instead of a branch.
A concrete scenario
Suppose you have a main branch and a feature branch that have diverged. You run git merge feature and see a merge commit appear with two parents. Then you reset and try git rebase main on feature instead, and watch the feature commits get copied on top of main with new hashes. That side-by-side experience is the part that tends to stick, because you see why rebase produces a linear history and why it changes commit identity.
Trade-offs to keep in mind
The environment is a browser simulation, so it teaches branching and history manipulation well but does not cover everything a real repository involves — remote authentication, hooks, submodules, or resolving conflicts in actual files. Treat it as a way to build a correct mental model of the graph, then practice those commands in a throwaway local repo.
Next step
Work through the levels once for the graph intuition, then immediately recreate the same sequence in a scratch repository on your own machine. If you want a written reference alongside it, the official Git documentation is at Git.
Can I practice Git commands without installing Git on my computer?
Yes. Learn Git Branching runs a simulated Git repository directly in your browser, so you can type commands and see how commits, branches and merges behave without installing anything locally.
What that means in practice
The page simulates a repository and renders a visual commit graph next to a terminal, so each command you enter visibly moves branches and HEAD. This is useful if you want to:
- Try
git branch,git checkout,git mergeandgit rebasesafely, with no risk to real work. - Build intuition for how commits relate to branches before touching a real project.
- Practise on a locked-down or shared computer where you cannot install software.
Trade-offs to keep in mind
A browser simulator is a teaching model, not a full Git installation. You will not be practising your local configuration, SSH keys, remote authentication, hooks, submodules or conflict resolution in real files. The commands are real Git concepts, but the environment is simplified.
If you also want to practise against actual files and a real remote, GitHub's own documentation and sandbox-style guides are a reasonable complement: GitHub Docs.
A practical next step
Open the site, start with the introductory sequence rather than jumping to rebase, and after each exercise write down in one sentence what the graph looked like before and after. When the visual model feels predictable, install Git locally and repeat the same branch-and-merge exercise on a throwaway repository — that is the point where the simulated knowledge transfers.
What specific Git branching concepts and commands can I learn through this tool?
You can learn the core branching model of Git by manipulating a simulated repository in your browser and watching the commit graph update after each command. Learn Git Branching is built around that visual feedback loop, so the concepts it teaches best are the ones where the shape of the graph matters.
Concepts it covers
- Commits as nodes and branches as movable pointers, which makes "a branch is just a label" concrete rather than abstract.
- Relative references:
HEAD,^and~for walking backwards through history, and how they differ when a commit has multiple parents. - Divergence and convergence: how two branches drift apart after a shared ancestor, and what it takes to bring them back together.
- Merge versus rebase, including the trade-off between preserving history and producing a linear sequence.
- Detached
HEAD, and why moving around without a branch pointing at your work is risky. - Remote-tracking branches and the local/remote distinction, plus how fetching differs from pulling.
Commands you practise
git commit, git branch, git checkout (and the newer git switch idea), git merge, git rebase, git cherry-pick, git reset, git revert, git tag, git fetch, git pull, git push, and git clone. The tool also mentions a Mercurial (Hg) mode, so the same graph reasoning can be compared across two systems.
How the learning actually works
The app runs a simulated repository in your browser and requires JavaScript. You type real Git commands into a terminal pane; the commit graph on the left redraws to show the result. Because the graph is visible, a mistake is instructive rather than merely annoying — you can see exactly which pointer moved.
Who gets the most from it
- Beginners who have used
git commitandgit pushbut freeze when a merge conflict or a detachedHEADappears. - Developers who can follow recipes but cannot predict what
git reset --hard HEAD~2will do to their branch. - Anyone preparing for a workflow where rebasing is expected and wants to rehearse it somewhere disposable.
Where it stops
It is a sandbox, not a full environment. You will not practise conflict resolution inside real files, hooks, submodules, .gitignore behaviour, or the social side of reviewing a pull request. Treat it as the place to build the mental model, then apply that model in a scratch clone of a real repository.
A useful next step: after finishing a level on rebase or reset, open a throwaway clone and repeat the same sequence there, checking git log --oneline --graph --all after every command. If the graph matches what you predicted in the tool, the concept has transferred. For a text-based reference to pair with it, the official Git documentation at Git covers the same commands with full option lists once you know which ones you need.
Is Learn Git Branching suitable for beginners or does it require prior Git experience?
Learn Git Branching suits beginners, but it works best if you have a basic idea of what a commit is and why branches exist. It's a browser-based simulator that renders Git's commit graph visually, so you can see branches move as you type commands. That visual feedback is the main reason it's beginner-friendly: instead of memorizing what git merge does from a manual, you watch the graph change.
Learn Git Branching
Where it helps beginners
- Branching and merging concepts. The graph view makes divergent and convergent history concrete rather than abstract.
- Safe experimentation. You work inside a simulated repository, so mistakes don't damage anything real.
- Guided progression. The site is structured as levels, starting with basic commit and branch operations before moving into rebasing and more advanced history manipulation.
Where prior experience matters
The tool focuses on branching and history, not on everyday repository setup. A complete beginner may still need to learn how to install Git, initialize a repo, stage files, and commit before the lessons feel grounded. The interface is terminal-style, so comfort with typing commands helps. If you've never opened a terminal, expect a short adjustment period.
A practical way to decide
Ask yourself one question: can you explain what a branch points to? If not, spend an hour on the basics first, then use this site to make branching click. If you already know the basics but find rebase, cherry-pick, or detached HEAD confusing, this is a strong fit — the visualization is exactly the tool for those topics.
A good next step is to pair the site with a reference you can consult for command syntax while you work through the levels. Git is the official documentation and a sensible companion, and GitHub hosts plenty of beginner repositories where you can practice the same commands on real projects once the simulated levels start feeling easy.
How does the browser simulation of a Git repository work?
The simulation is a self-contained app that runs entirely in the browser: it implements a Git-like command interpreter and repository model in JavaScript, renders the commit graph visually, and responds to the commands you type in its terminal pane. Nothing is installed locally and nothing is sent to a server, so you can experiment freely without touching a real project.
Learn Git Branching
H3 How the pieces fit together
- Terminal input. You type Git commands into an in-page terminal. The app parses them and applies them to its internal model rather than calling a real
gitbinary. - Repository model. Commits, branches, tags, HEAD and the staging area exist as data structures inside the page. Each command mutates that model.
- Visual graph. The commit graph is redrawn after each command, so you can see how a branch moves, where HEAD points, and how merges or rebases reshape history.
- Levels and challenges. Tasks give you a goal state; the app checks your graph against it, which turns abstract commands into something you can verify by eye.
H3 What this means in practice
Because the repository is simulated, mistakes are cheap: you can reset, rebase or delete branches to see what happens, then reload the page. The trade-off is fidelity. A browser model is designed for teaching, so it emphasizes branch topology and command effects; it won't reproduce everything about a real working tree, hooks, remote authentication or merge conflicts in large codebases.
A useful way to use it: pick one concept you keep getting wrong, such as rebasing a feature branch onto main, and work through the relevant level until the graph matches what you intended. Then repeat the same sequence in a throwaway local repository to confirm the commands behave as expected with real files. For reference alongside it, the official Git documentation covers the same commands in full detail.
Cloudflare
Fastly
User reviews (0)