Using Git In Visual Studio Code

Home / Version Controlling with Git in Visual Studio Code and Azure DevOps


Version control in VS Code. In this tutorial, we will learn how to use the basics of Git version control in Visual Studio Code. For more information about integrated Git support, including how to work with remote repositories, read on in the related resources section below. Using GitHub with Visual Studio Code lets you share your source code and collaborate with others. GitHub integration is provided through the GitHub Pull Requests and Issues extension. Install the GitHub Pull Requests and Issues extension. Let's define a git remote with the url of Visual Studio Team Services (VSTS). Here, I would like to mention that I have an account on Visual Studio Team Services and this is free to use up to 5 users. So if you have a small team of 5 members, you should give it a try. Git Bash is an application that provides Git command line experience on the Operating System. It is a command-line shell for enabling git with the command line in the system. VSCode is a Text editor that provides support for development operations and version control systems. It provides tools for a user to build hassle-free codes. Introduction to Git, GitHub with Visual Studio Code. GitHub is the most well-known code repository site in the world today. Backed by Git, it makes working with the distributed source control access for all developers. Git is an industry-standard tool that all developers are expected to know.

Azure DevOps supports two types of version control, Git and Team Foundation Version Control (TFVC). Here is a quick overview of the two version control systems:

  • Team Foundation Version Control (TFVC): TFVC is a centralized version control system. Typically, team members have only one version of each file on their dev machines. Historical data is maintained only on the server. Branches are path-based and created on the server.

    Well played pdf free download

  • Git: Git is a distributed version control system. Git repositories can live locally (such as on a developer’s machine). Each developer has a copy of the source repository on their dev machine. Developers can commit each set of changes on their dev machine and perform version control operations such as history and compare without a network connection.

Git is the default version control provider for new projects. You should use Git for version control in your projects unless you have a specific need for centralized version control features in TFVC.

In this lab, you will learn how to establish a local Git repository, which can easily be synchronized with a centralized Git repository in Azure DevOps. In addition, you will learn about Git branching and merging support. You will use Visual Studio Code, but the same processes apply for using any Git-compatible client with Azure DevOps.


  • Visual Studio Code with the C# extension installed.

  • Git for Windows 2.21.0 or later.

  • This lab requires you to complete task 1 from the prerequisite instructions (Skip cloning, it is done in the exercise).

Exercise 1: Configuring the lab environment

Task 1: Configuring Visual Studio Code

  1. Open Visual Studio Code. In this task, you will configure a Git credential helper to securely store the Git credentials used to communicate with Azure DevOps. If you have already configured a credential helper and Git identity, you can skip to the next task.

  2. From the main menu, select Terminal New Terminal to open a terminal window.

  3. Execute the command below to configure a credential helper.

  4. The commands below will configure your user name and email for Git commits. Replace the parameters with your preferred user name and email and execute them.

Exercise 2: Cloning an existing repository

Task 1: Cloning an existing repository

  1. In a browser tab, navigate to your team project on Azure DevOps.

  2. Getting a local copy of a Git repo is called “cloning”. Every mainstream development tool supports this and will be able to connect to Azure Repos to pull down the latest source to work with. Navigate to the Repos hub.

  3. Click Clone.

  4. Click the Copy to clipboard button next to the repo clone URL. You can plug this URL into any Git-compatible tool to get a copy of the codebase.

  5. Open an instance of Visual Studio Code.

  6. Press Ctrl+Shift+P to show the Command Palette. The Command Palette provides an easy and convenient way to access a wide variety of tasks, including those provided by 3rd party extensions.

  7. Execute the Git: Clone command. It may help to type “Git” to bring it to the shortlist.

  8. Paste in the URL to your repo and press Enter.

  9. Select a local path to clone the repo to.

  10. When prompted, log in to your Azure DevOps account.

  11. Once the cloning has completed, click Open to open the cloned repository. You can ignore any warnings raised about opening the projects. The solution may not be in a buildable state, but that’s okay since we’re going to focus on working with Git and building the project itself is not necessary.

Exercise 3: Saving work with commits

When you make changes to your files, Git will record the changes in the local repository. You can select the changes that you want to commit by staging the changes. Commits are always made against your local Git repository, so you don’t have to worry about the commit being perfect or ready to share with others. You can make more commits as you continue to work and push the changes to others when they are ready to be shared.

What’s in a commit?

Git commits consists of the following:

  • The file(s) changed in the commit. Git keeps the contents of all file changes in your repo in the commits. This keeps it fast and allows intelligent merging.

  • A reference to the parent commit(s). Git manages your code history using these references.

  • A message describing a commit. You give this message to Git when you create the commit. It’s a good idea to keep this message descriptive, but to the point.

Task 1: Committing changes

Using Git In Visual Studio Code
  1. From the Explorer tab, open /PartsUnlimited-aspnet45/src/PartsUnlimitedWebsite/Models/CartItem.cs.

  2. Add a comment to the file. It doesn’t really matter what the comment is since the goal is just to make a change. Press Ctrl+S to save the file.

  3. Select the Source Control tab to see the one change to the solution.

  4. Enter a commit message of “My commit” and press Ctrl+Enter to commit it locally.

  5. If asked whether you would like to automatically stage your changes and commit them directly, click Always. We will discuss staging later in the lab.

  6. Click the Synchronize Changes button to synchronize your changes with the server. Confirm the sync if prompted.

Task 2: Reviewing commits

  1. Switch to the Azure DevOps browser tab. You can review the latest commits on Azure DevOps under the Commits tab of the Repos hub.

  2. The recent commit should be right at the top.

Task 3: Staging changes

Staging changes allows you to selectively add certain files to a commit while passing over the changes made in other files.

  1. Return to Visual Studio Code.

  2. Update the open CartItem.cs class by editing the comment you made earlier and saving the file.

  3. Open Category.cs as well.

  4. Add a new comment to Category.cs so there will be two files with changes. Save the file.

  5. From the Source Control tab, click the Stage Changes button for CartItem.cs.

  6. This will prepare CartItem.cs for committing without Category.cs.

  7. Enter a comment of “Added comments”. From the More Actions dropdown, select Commit Staged.

  8. Click the Synchronize Changes button to synchronize the committed changes with the server. Note that since only the staged changes were committed, the other changes are still pending locally.

Exercise 4: Reviewing history

Git uses the parent reference information stored in each commit to manage a full history of your development. You can easily review this commit history to find out when file changes were made and determine differences between versions of your code using the terminal or from one of the many Visual Studio Code extensions available. You can also review changes using the Azure DevOps portal.

Git’s use of the Branches and Merges feature works through pull requests, so the commit history of your development doesn’t necessarily form a straight, chronological line. When you use history to compare versions, think in terms of file changes between two commits instead of file changes between two points in time. A recent change to a file in the master branch may have come from a commit created two weeks ago in a feature branch but was only merged yesterday.

Task 1: Comparing files

  1. In the Source Control tab, select Category.cs.

  2. A comparison view is opened to enable you to easily locate the changes you’ve made. In this case, it’s just the one comment.

  3. Go to the Commits view in Azure DevOps to locate some of the source branches and merges. These provide a convenient way to visualize when and how changes were made to the source.

  4. From the dropdown for Merged PR 27, select Browse Files.

  5. This view offers the ability to navigate around the state of the source at that commit so you can review and download those files.

Exercise 5: Working with branches


You can manage the work in your Azure DevOps Git repo from the Branches view on the web. You can also customize the view to track the branches you care most about so you can stay on top of changes made by your team.

Committing changes to a branch will not affect other branches and you can share branches with others without having to merge the changes into the main project. You can also create new branches to isolate changes for a feature or a bug fix from your master branch and other work. Since the branches are lightweight, switching between branches is quick and easy. Git does not create multiple copies of your source when working with branches, but rather uses the history information stored in commits to recreate the files on a branch when you start working on it. Your Git workflow should create and use branches for managing features and bugfixes. The rest of the Git workflow, such as sharing code and reviewing code with pull requests, all work through branches. Isolating work in branches makes it very simple to change what you are working on by simply changing your current branch.

Task 1: Creating a new branch in your local repository

  1. Return to Visual Studio Code.

  2. Click the master branch from the bottom left.

  3. Select Create new branch from….

  4. Enter the name “dev” for the new branch and press Enter.

  5. Select the master as the reference branch.

  6. You are now working on that branch.

Task 2: Working with branches

Git keeps track of which branch you are working on and makes sure that when you checkout a branch your files match the most recent commit on the branch. Branches let you work with multiple versions of the source code in the same local Git repository at the same time. You can use Visual Studio Code to publish, check out and delete branches.

  1. Click the Publish changes button next to the branch.

  2. From the Azure DevOps browser tab, select Branches.

  3. You should see the newly pushed dev branch. Click on more actions drop down and Select the Delete branch button to delete it. Confirm the delete.

  4. Return to Visual Studio Code.

  5. Click the dev branch.

  6. Note that there are two dev branches listed. The local (dev) branch is there because it’s not deleted when the server branch is deleted. The server (origin/dev) is there because it hasn’t been pruned. Select the master branch to check it out.

  7. Press Ctrl+Shift+P to open the Command Palette.

  8. Start typing “Git: Delete” and select Git: Delete Branch when it becomes visible.

  9. There is only one local branch to delete, so select it.

  10. Click the master branch.

  11. Note that the local dev branch is gone, but the remote origin/dev is still showing.

  12. Press Ctrl+Shift+P to open the Command Palette.

  13. Start typing “Git: Fetch” and select Git: Fetch (Prune) when it becomes visible. This command will update the origin branches in the local snapshot and delete those that are no longer there.

  14. You can check in on exactly what these tasks are doing by selecting the Output window at the bottom of the screen.

  15. Note that if you don’t see the Git logs in the output console, you may need to select Git as the source.

  16. Click the master branch.

  17. The origin/dev branch should no longer be in the list.

Exercise 6: Managing branches from Azure DevOps

In addition to all the functionality available in Visual Studio Code, you can also manage your repo branches from the Azure DevOps portal.

Task 1: Creating a new branch

  1. Switch to the Azure DevOps browser tab.

  2. Navigate to Repos Branches. Click New branch.

  3. Enter a name of “release” for the new branch. Use the Work items to link dropdown to select one or more work items to link to this new branch. Click Create branch to create it.

  4. After the branch has been created, it will be available in the list.

  5. Return to Visual Studio Code.

  6. Press Ctrl+Shift+P to open the Command Palette.

  7. Start typing “Git: Fetch” and select Git: Fetch when it becomes visible. This command will update the origin branches in the local snapshot.

  8. Click the master branch.

  9. Select origin/release. This will create a new local branch called “release” and check it out.

Task 2: Deleting a branch

  1. Return to Azure DevOps and click the Delete branch from the more actions drop down to delete it.

  2. You can Restore branch if you want by searching for an exact branch name. Select Restore branch as shown below.

Task 3: Locking a branch

Locking is ideal for preventing new changes that might conflict with an important merge or to place a branch into a read-only state. Alternatively, you can use branch policies and pull requests instead of locking if you just want to ensure that changes in a branch are reviewed before they are merged.

Locking does not prevent cloning of a repo or fetching updates made in the branch into your local repo. If you lock a branch, share with your team the reason why and make sure they know what to do to work with the branch after it is unlocked.

  1. From the master context menu, select Lock.

  2. The branch is now locked.

  3. Now Unlock the branch using the same process.

Vs Code Git Pull

Task 4: Tagging a release

  1. While it may not seem like much, the product team has decided that this version of the site is exactly what’s needed for v1.1. In order to mark it as such, navigate to the Tags tab.

  2. Click Create Tag.

  3. Enter a name of “v1.1” and a Description of “Great release!”. Click Create.

  4. You have now tagged the project at this release. You could tag commits for a variety of reasons and Azure DevOps offers the flexibility to edit and delete them, as well as manage their permissions.

    ## ##

Install Git Visual Code

Exercise 7: Managing repositories

You can create Git repos in team projects to manage your project’s source code. Each Git repo has its own set of permissions and branches to isolate itself from other work in your project.

Using Github In Visual Studio Code

Task 1: Creating a new repo from Azure DevOps

Using Git In Visual Studio Code

  1. From the project Add dropdown, select New repository.

  2. Set the Repository name to “New Repo”. Note that you also have the option to create a file named This would be the default markdown file that is rendered when someone navigates to the repo root in a browser. Additionally, you can preconfigure the repo with a .gitignore file. This file specifies which files, based on naming pattern and/or path, to ignore from source control. There are multiple templates available that include the common patterns and paths to ignore based on the project type you are creating. Click Create.

  3. That’s it. Your repo is ready. You can now clone it with Visual Studio or your tools of choice.

Visual Studio Code Git Push

Task 2: Deleting and renaming Git repos

Using Git With Vs Code

  1. Sometimes you’ll have a need to rename or delete a repo, which is just as easy. Open Project settings.

  2. Select Repositories under Repos.

  3. From the New Repo context menu, select Delete repository. Alternatively, you could rename it here.

  4. Enter the name “New Repo” to confirm the repo and click Delete.

Git Use Visual Studio Code As Default Editor

View a Git Graph of your repository, and easily perform Git actions from the graph. Configurable to look the way you want!


  • Git Graph View:
    • Display:
      • Local & Remote Branches
      • Local Refs: Heads, Tags & Remotes
      • Uncommitted Changes
    • Perform Git Actions (available by right clicking on a commit / branch / tag):
      • Create, Checkout, Delete, Fetch, Merge, Pull, Push, Rebase, Rename & Reset Branches
      • Add, Delete & Push Tags
      • Checkout, Cherry Pick, Drop, Merge & Revert Commits
      • Clean, Reset & Stash Uncommitted Changes
      • Apply, Create Branch From, Drop & Pop Stashes
      • View annotated tag details (name, email, date and message)
      • Copy commit hashes, and branch, stash & tag names to the clipboard
    • View commit details and file changes by clicking on a commit. On the Commit Details View you can:
      • View the Visual Studio Code Diff of any file change by clicking on it.
      • Open the current version of any file that was affected in the commit.
      • Copy the path of any file that was affected in the commit to the clipboard.
      • Click on any HTTP/HTTPS url in the commit body to open it in your default web browser.
    • Compare any two commits by clicking on a commit, and then CTRL/CMD clicking on another commit. On the Commit Comparison View you can:
      • View the Visual Studio Code Diff of any file change between the selected commits by clicking on it.
      • Open the current version of any file that was affected between the selected commits.
      • Copy the path of any file that was affected between the selected commits to the clipboard.
    • Code Review - Keep track of which files you have reviewed in the Commit Details & Comparison Views.
      • Code Review's can be performed on any commit, or between any two commits (not on Uncommitted Changes).
      • When a Code Review is started, all files needing to be reviewed are bolded. When you view the diff / open a file, it will then be un-bolded.
      • Code Reviews persist across Visual Studio Code sessions. They are automatically closed after 90 days of inactivity.
    • View uncommitted changes, and compare the uncommitted changes with any commit.
    • Hover over any commit vertex on the graph to see a tooltip indicating:
      • Whether the commit is included in the HEAD.
      • Which branches, tags and stashes include the commit.
    • Filter the branches shown in Git Graph using the 'Branches' dropdown menu. The options for filtering the branches are:
      • Show All branches
      • Select one or more branches to be viewed
      • Select from a user predefined array of custom glob patterns (by setting git-graph.customBranchGlobPatterns)
    • Fetch from Remote(s) (available on the top control bar)
    • Find Widget allows you to quickly find one or more commits containing a specific phrase (in the commit message / date / author / hash, branch or tag names).
    • Repository Settings Widget:
      • Allows you to view, add, edit, delete, fetch & prune remotes of the repository.
      • Configure 'Issue Linking' - Converts issue numbers in commit messages into hyperlinks, that open the issue in your issue tracking system.
      • Configure 'Pull Request Creation' - Automates the opening and pre-filling of a Pull Request form, directly from a branches context menu.
        • Support for the publicly hosted Bitbucket, GitHub and GitLab Pull Request providers is built-in.
        • Custom Pull Request providers can be configured using the Extension Setting git-graph.customPullRequestProviders (e.g. for use with privately hosted Pull Request providers). Information on how to configure custom providers is available here.
      • Export your Git Graph Repository Configuration to a file that can be committed in the repository. It allows others working in the same repository to automatically use the same Git Graph configuration.
    • Keyboard Shortcuts (available in the Git Graph View):
      • CTRL/CMD + F: Open the Find Widget.
      • CTRL/CMD + H: Scrolls the Git Graph View to be centered on the commit referenced by HEAD.
      • CTRL/CMD + R: Refresh the Git Graph View.
      • CTRL/CMD + S: Scrolls the Git Graph View to the first (or next) stash in the loaded commits.
      • CTRL/CMD + SHIFT + S: Scrolls the Git Graph View to the last (or previous) stash in the loaded commits.
      • When the Commit Details View is open on a commit:
        • Up / Down: The Commit Details View will be opened on the commit directly above or below it on the Git Graph View.
        • CTRL/CMD + Up / CTRL/CMD + Down: The Commit Details View will be opened on its child or parent commit on the same branch.
          • If the Shift Key is also pressed (i.e. CTRL/CMD + SHIFT + Up / CTRL/CMD + SHIFT + Down), when branches or merges are encountered the alternative branch is followed.
      • Enter: If a dialog is open, pressing enter submits the dialog, taking the primary (left) action.
      • Escape: Closes the active dialog, context menu or the Commit Details View.
    • Resize the width of each column, and show/hide the Date, Author & Commit columns.
    • Common Emoji Shortcodes are automatically replaced with the corresponding emoji in commit messages (including all gitmoji). Custom Emoji Shortcode mappings can be defined in git-graph.customEmojiShortcodeMappings.
  • A broad range of configurable settings (e.g. graph style, branch colours, and more..). See the 'Extension Settings' section below for more information.
  • 'Git Graph' launch button in the Status Bar
  • 'Git Graph: View Git Graph' launch command in the Command Palette

Extension Settings

Detailed information of all Git Graph settings is available here, including: descriptions, screenshots, default values and types.

A summary of the Git Graph extension settings are:

  • Commit Details View:
    • Auto Center: Automatically center the Commit Details View when it is opened.
    • File View:
      • File Tree:
        • Compact Folders: Render the File Tree in the Commit Details View in a compacted form, such that folders with a single child folder are compressed into a single combined folder element.
      • Type: Sets the default type of File View used in the Commit Details View.
    • Location: Specifies where the Commit Details View is rendered in the Git Graph View.
  • Context Menu Actions Visibility: Customise which context menu actions are visible. For more information, see the documentation here.
  • Custom Branch Glob Patterns: An array of Custom Glob Patterns to be shown in the 'Branches' dropdown. Example: [{'name':'Feature Requests', 'glob':'heads/feature/*'}]
  • Custom Emoji Shortcode Mappings: An array of custom Emoji Shortcode mappings. Example: [{'shortcode': ':sparkles:', 'emoji':'✨'}]
  • Custom Pull Request Providers: An array of custom Pull Request providers that can be used in the 'Pull Request Creation' Integration. For information on how to configure this setting, see the documentation here.
  • Date:
    • Format: Specifies the date format to be used in the 'Date' column on the Git Graph View.
    • Type: Specifies the date type to be displayed in the 'Date' column on the Git Graph View, either the author or commit date.
  • Default Column Visibility: An object specifying the default visibility of the Date, Author & Commit columns. Example: {'Date': true, 'Author': true, 'Commit': true}
  • Dialog > *: Set the default options on the following dialogs: Add Tag, Apply Stash, Cherry Pick, Create Branch, Delete Branch, Fetch into Local Branch, Fetch Remote, Merge, Pop Stash, Pull Branch, Rebase, Reset, and Stash Uncommitted Changes
  • Enhanced Accessibility: Visual file change A M D R U indicators in the Commit Details View for users with colour blindness. In the future, this setting will enable any additional accessibility related features of Git Graph that aren't enabled by default.
  • File Encoding: The character set encoding used when retrieving a specific version of repository files (e.g. in the Diff View). A list of all supported encodings can be found here.
  • Graph:
    • Colours: Specifies the colours used on the graph.
    • Style: Specifies the style of the graph.
    • Uncommitted Changes: Specifies how the Uncommitted Changes are displayed on the graph.
  • Integrated Terminal Shell: Specifies the path and filename of the Shell executable to be used by the Visual Studio Code Integrated Terminal, when it is opened by Git Graph.
  • Keyboard Shortcut > *: Configures the keybindings used for all keyboard shortcuts in the Git Graph View.
  • Markdown: Parse and render a frequently used subset of inline Markdown formatting rules in commit messages and tag details (bold, italics, bold & italics, and inline code blocks).
  • Max Depth Of Repo Search: Specifies the maximum depth of subfolders to search when discovering repositories in the workspace.
  • Open New Tab Editor Group: Specifies the Editor Group where Git Graph should open new tabs, when performing the following actions from the Git Graph View: Viewing the Visual Studio Code Diff View, Opening a File, Viewing a File at a Specific Revision.
  • Open to the Repo of the Active Text Editor Document: Open the Git Graph View to the repository containing the active Text Editor document.
  • Reference Labels:
    • Alignment: Specifies how branch and tag reference labels are aligned for each commit.
    • Combine Local and Remote Branch Labels: Combine local and remote branch labels if they refer to the same branch, and are on the same commit.
  • Repository:
    • Commits:
      • Fetch Avatars: Fetch avatars of commit authors and committers.
      • Initial Load: Specifies the number of commits to initially load.
      • Load More: Specifies the number of additional commits to load when the 'Load More Commits' button is pressed, or more commits are automatically loaded.
      • Load More Automatically: When the view has been scrolled to the bottom, automatically load more commits if they exist (instead of having to press the 'Load More Commits' button).
      • Mute:
        • Commits that are not ancestors of HEAD: Display commits that aren't ancestors of the checked-out branch / commit with a muted text color.
        • Merge Commits: Display merge commits with a muted text color.
      • Order: Specifies the order of commits on the Git Graph View. See git log for more information on each order option.
      • Show Signature Status: Show the commit's signature status to the right of the Committer in the Commit Details View (only for signed commits). Hovering over the signature icon displays a tooltip with the signature details.
    • Fetch and Prune: Before fetching from remote(s) using the Fetch button on the Git Graph View Control Bar, remove any remote-tracking references that no longer exist on the remote(s).
    • Fetch And Prune Tags: Before fetching from remote(s) using the Fetch button on the Git Graph View Control Bar, remove any local tags that no longer exist on the remote(s).
    • Include Commits Mentioned By Reflogs: Include commits only mentioned by reflogs in the Git Graph View (only applies when showing all branches).
    • On Load:
      • Scroll To Head: Automatically scroll the Git Graph View to be centered on the commit referenced by HEAD.
      • Show Checked Out Branch: Show the checked out branch when a repository is loaded in the Git Graph View.
      • Show Specific Branches: Show specific branches when a repository is loaded in the Git Graph View.
    • Only Follow First Parent: Only follow the first parent of commits when discovering the commits to load in the Git Graph View. See --first-parent to find out more about this setting.
    • Show Commits Only Referenced By Tags: Show Commits that are only referenced by tags in Git Graph.
    • Show Remote Branches: Show Remote Branches in Git Graph by default.
    • Show Remote Heads: Show Remote HEAD Symbolic References in Git Graph.
    • Show Stashes: Show Stashes in Git Graph by default.
    • Show Tags: Show Tags in Git Graph by default.
    • Show Uncommitted Changes: Show uncommitted changes. If you work on large repositories, disabling this setting can reduce the load time of the Git Graph View.
    • Show Untracked Files: Show untracked files when viewing the uncommitted changes. If you work on large repositories, disabling this setting can reduce the load time of the Git Graph View.
    • Sign:
      • Commits: Enables commit signing with GPG or X.509.
      • Tags: Enables tag signing with GPG or X.509.
    • Use Mailmap: Respect .mailmap files when displaying author & committer names and email addresses.
  • Repository Dropdown Order: Specifies the order that repositories are sorted in the repository dropdown on the Git Graph View (only visible when more than one repository exists in the current Visual Studio Code Workspace).
  • Retain Context When Hidden: Specifies if the Git Graph view Visual Studio Code context is kept when the panel is no longer visible (e.g. moved to background tab). Enabling this setting will make Git Graph load significantly faster when switching back to the Git Graph tab, however has a higher memory overhead.
  • Show Status Bar Item: Show a Status Bar Item that opens the Git Graph View when clicked.
  • Source Code Provider Integration Location: Specifies where the 'View Git Graph' action appears on the title of SCM Providers.
  • Tab Icon Colour Theme: Specifies the colour theme of the icon displayed on the Git Graph tab.

This extension consumes the following settings:

  • git.path: Specifies the path and filename of a portable Git installation.

Extension Commands

This extension contributes the following commands:

  • git-graph.view: Git Graph: View Git Graph
  • git-graph.addGitRepository: Git Graph: Add Git Repository.. (used to add sub-repos to Git Graph)
  • git-graph.clearAvatarCache: Git Graph: Clear Avatar Cache
  • git-graph.endAllWorkspaceCodeReviews: Git Graph: End All Code Reviews in Workspace
  • git-graph.endSpecificWorkspaceCodeReview: Git Graph: End a specific Code Review in Workspace.. (used to end a specific Code Review without having to first open it in the Git Graph View)
  • git-graph.fetch: Git Graph: Fetch from Remote(s) (used to open the Git Graph View and immediately run 'Fetch from Remote(s)')
  • git-graph.removeGitRepository: Git Graph: Remove Git Repository.. (used to remove repositories from Git Graph)
  • git-graph.resumeWorkspaceCodeReview: Git Graph: Resume a specific Code Review in Workspace.. (used to open the Git Graph View to a Code Review that is already in progress)
  • git-graph.version: Git Graph: Get Version Information

Release Notes

Detailed Release Notes are available here.

Visual Studio Marketplace

This extension is available on the Visual Studio Marketplace for Visual Studio Code.


Thank you to all of the contributors that help with the development of Git Graph!

Some of the icons used in Git Graph are from the following sources, please support them for their excellent work!

  • GitHub Octicons (License)
  • Icons8 (License)