An interactive git visualization and tutorial. Aspiring students of git can use this app to educate and challenge themselves towards mastery of git!
Alternatives To Learngitbranching
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Learngitbranching28,79519 days ago1May 29, 201925mitJavaScript
An interactive git visualization and tutorial. Aspiring students of git can use this app to educate and challenge themselves towards mastery of git!
Git Sim3,684
3 months ago33July 05, 20238gpl-2.0Python
Visually simulate Git operations in your own repos with a single terminal command.
Git Cola2,129
15 days ago14November 19, 202367gpl-2.0Python
git-cola: The highly caffeinated Git GUI
Oh My Git1,304
3 months ago97otherGDScript
An interactive Git learning game!
Git Big Picture521
4 days ago8September 27, 202211gpl-3.0Python
Git — the big picture
2 years ago18apache-2.0JavaScript
Visualization the history of repository changes based on data from GitHub
Git Cheatsheet316
24 days ago5mitJavaScript
Interactive cheatsheet, visualization of git.
Git Deps291
12 months ago6April 04, 202156gpl-2.0Python
git commit dependency analysis tool
Git Heatmap253
a year ago6mitShell
:bar_chart: Display a heatmap for oft-edited files
Git Story217
14 days ago4mitPython
Easily create video animations (.mp4) of your Git commit history, directory from your Git repo.
Alternatives To Learngitbranching
Select To Compare

Alternative Project Comparisons


PRs Welcome

LearnGitBranching is a git repository visualizer, sandbox, and a series of educational tutorials and challenges. Its primary purpose is to help developers understand git through the power of visualization (something that's absent when working on the command line). This is achieved through a game with different levels to get acquainted with the different git commands.

You can input a variety of commands into LearnGitBranching (LGB) -- as commands are processed, the nearby commit tree will dynamically update to reflect the effects of each command:


This visualization combined with tutorials and "levels" can help both beginners and intermediate developers polish their version control skills. A quick demo is available here: https://pcottle.github.io/learnGitBranching/?demo

Or, you can launch the application normally here: https://pcottle.github.io/learnGitBranching/

Sandbox Mode

By default the application launches in "sandbox mode" with a basic repository already created. Here you can enter commands and mess around with a repository as much as you like. Keep in mind you can

  • undo to undo the effects of the last command
  • reset to start over with a clean slate (works in levels too)
  • git clone to simulate remote repositories!

Sandbox mode can be great for demonstrating something to a friend, but the real learning is with levels...


Type levels to see the available lessons / challenges (and which ones you have solved so far). Each level series aims to teach some high-level git concept, and each tab of levels separates major worlds of info (like remote repositories versus local).

For some added fun, there is a "git golf" concept where we keep track of how many commands you use to solve each level. See if you can match all of our records!

Sharing permalinks

You can share a link to LearnGitBranching with an arbitrary set of commands that will execute upon load by using the command URL parameter. You will also likely want to disable the intro dialog for this case with the NODEMO url param; here is an example to get started.

Level Builder

You can build levels with the build level command. A dialog will walk you through the process, and at the end it will show you a JSON blob that represents the level you just created. Paste that in a gist or directly into an issue and I can check it out / merge in your changes! You can also share this level directly with friends by having them run import level and paste the JSON in the resulting text field, or simply send them a custom URL with the the gist ID in the parameters, like so: https://pcottle.github.io/learnGitBranching/?gist_level_id=a84407351f9c9f0cb241

Reporting Bugs / Opening Issues

When reporting bugs, try running the command debug_copyTree() in your JS console when in a state just before reproducing a bug. This can avoid having to copy all the commands you used to get into a specific state. (I can then use the importTreeNow command to get to that exact state)

Building yourself / Contributing Functionality

For contributing core functionality in the app, you'll probably want to test your changes at least once before submitting a pull request. That means you'll need the "gulp.js" build tool to build the app:


You'll also need yarn to download all the dependencies of the project.

The general workflow / steps are below:

git clone <your fork of the repo>
cd learnGitBranching
yarn install

git checkout -b newAwesomeFeature
vim ./src/js/git/index.js # some changes
yarn gulp fastBuild # skips tests and linting, faster build

# after building you can open up your browser to the index.html
open ./index.html
# file generated and see your changes

vim ./src/js/git/index.js # more changes
yarn gulp build # runs tests and lint

git commit -am "My new sweet feature!"
git push
# go online and request a pull

Alternatively, you can also build and run the app in a pre-configured online workspace:

Open in Gitpod

Other Technical Details

LearnGitBranching is a pretty simple application (from a technical perspective). There's no backend database or any AJAX requests -- it's a 100% clientside application written in JavaScript. The production version (on github.io) literally just serves up an HTML page with some JS and CSS.

Here is the high-level process of the build:

  • CSS is written into just one stylesheet (there is not a whole ton of styling)
  • New HTML is written into a template HTML file (template.index.html). This is only needed for new views
  • The app is "built", which outputs:
    • index.html in the root directory
    • CSS and JS files in ./build directory
  • If the app is being built for production, then these CSS and JS files are hashed (to bust caches) and tests are run
  • That's it!

Thus, if you build the app locally, all you have to do in order to run the app is just open up index.html in the root directory of the repo. Pretty simple


You can run the most recently built stable image with docker run -p 8080:80 ghcr.io/pcottle/learngitbranching:main. Access your environment with at http://localhost:8080/

You can build the app and image with the command: docker build -t ghcr.io/pcottle/learngitbranching:latest. See the Makefile for information on how to build locally with docker.

Some of our amazing contributors

Helpful Folks

A big shoutout to these brave souls for extensively testing our sandbox and finding bugs and/or inconsistencies:

  • Nikita Kouevda
  • Maksim Ioffe
  • Dan Miller

And the following heroes for assisting in translating:

  • Jake Chen
  • ("urigit")
  • "bcho"
  • "scientific-coder"
  • "ace-coder"
  • Jol Thieffry
  • Jens Bremmekamp ("nem75")
  • "hilojack"
  • Ming-Hsuan-Tu ("twmht")
  • Mikhail Usov ("mikhailusov")
  • Matias Garcia Isaia ("mgarciaisaia")
  • Marc-Olivier Arsenault ("marcolivierarsenault")
  • Eroany H Leader ("lhyqy5")
  • Honorat ("ahonorat")
  • Vasil Kulakov ("coyl") & Lyubov Agadjanyan ("shayenblue")
  • Aliaksei Berkau ("alexeiberkov")
  • Mizunashi Mana ("mizunashi-mana")
  • YourSenseiCreeper
  • Olsza

Also huge shoutout for everyone who has put up a pull request that was pulled! Check out the 30+ contributors we have in the Contributors View

And everyone who has reported an issue that was successfully closed!

Popular Visualization Projects
Popular Git Projects
Popular User Interface Categories

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.