Home Git How to smoothly checkout a remote Git branch

How to smoothly checkout a remote Git branch

It covers everything from fetching the latest updates to checking out remote branches, aimed at helping developers maintain an efficient and error-free workflow in their version control practices.

by Arun Kumar
checkout a remote git branch

In the ever-evolving world of software development, mastering Git is an indispensable skill for developers and teams alike. In this guide, we delve into some of the more nuanced yet essential aspects of Git, focusing on checking out remote branches, handling name clashes, and managing multiple remote repositories.

Whether you’re a seasoned developer or just starting out, these insights will help streamline your workflow in Git, making your version control experience smoother and more efficient.

Understanding Git branches

Before we jump into the how-to, it’s essential to grasp what a Git branch is. Think of it as an independent line of development. You can work on new features, fix bugs, or experiment without affecting the main project.

Why branches matter

Branches are the backbone of any Git workflow. They allow multiple developers to work simultaneously without stepping on each other’s toes. It’s like having your own sandbox to build a castle, without the fear of someone else’s tide washing it away.

Setting up your environment

Before we begin, ensure you have Git installed on your Ubuntu system. Open your terminal and run:

sudo apt update
sudo apt install git

Using other distros?: See this: The Linux user’s guide to installing and setting up Git

Verify your Git installation

Run git --version to ensure it’s correctly installed. It’s a small step, but skipping it is like trying to drive without checking if you have gas!

When you run git --version, your terminal might show:

git version 2.25.1

This output confirms the installed Git version.

Checking out a remote branch

Now, for the main event! Let’s break it down into simple steps.

1. Fetch the remote branches

First, make sure you have the latest list of branches from your remote repository:

git fetch

This command is like asking, “Hey Git, what’s new out there?”

After running git fetch, you might not see a detailed output. This command quietly updates your local metadata without any fanfare. However, if there are updates, it might look like this:

remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 2.76 KiB | 141.00 KiB/s, done.
From https://github.com/your-repository
   a1b2c3d..e4f5g6h  main     -> origin/main

2. View all branches

To see all available branches, use:

git branch -a

It’s like opening a map before choosing your path.

When you list all branches with git branch -a, the output will be something like:

* main
  remotes/origin/HEAD -> origin/main

This shows your local branches and the remote-tracking branches.

3. Checkout the desired branch

Say you want to switch to a branch named feature-x. Here’s how:

git checkout feature-x

If the branch doesn’t exist locally, Git will set it up for you. It’s like magic, but better because it’s real!

Finally, checking out a branch like feature-x will display:

Branch 'feature-x' set up to track remote branch 'feature-x' from 'origin'.
Switched to a new branch 'feature-x'

This confirms that you’ve switched to the feature-x branch.

4. Handling name clashes

Encountering name clashes in Git can be like accidentally wearing someone else’s shoes – confusing and a bit uncomfortable. This typically happens when you have a local branch with the same name as the remote branch you’re trying to check out. Let’s walk through how to handle this situation.

Understanding the clash

Imagine you have a local branch named feature-x and there’s also a remote branch with the same name. When you try to check out the remote feature-x, Git might get confused. It’s like telling your GPS to take you to Springfield, but which one?

Resolving the clash

Option 1: Rename your local branch

If you don’t need the local branch anymore, or if it’s different from the remote branch, consider renaming it. Here’s how:

  1. Check your current branch: Make sure you are not on the branch you want to rename. You can switch to the main branch with git checkout main.
  2. Rename your branch: Use the following command to rename:
    git branch -m feature-x feature-x-old

    This changes your local feature-x to feature-x-old.

Option 2: Checkout with a different name

If you want to keep your local feature-x and also check out the remote feature-x, do this:

  1. Fetch the remote branches (if you haven’t already):
    git fetch
  2. Checkout the remote branch with a new name:
    git checkout -b feature-x-remote origin/feature-x

    This creates and switches to a new branch feature-x-remote, which tracks the remote feature-x.

Example output

When renaming your local branch:

Branch 'feature-x' renamed to 'feature-x-old'.

And when checking out the remote branch with a different name:

Branch 'feature-x-remote' set up to track remote branch 'feature-x' from 'origin'.
Switched to a new branch 'feature-x-remote'

5. Handling multiple remote repositories

Working with multiple remote repositories in Git is like juggling; it requires skill, attention, and a bit of practice. This situation often arises in complex workflows, where you might need to interact with different repositories for various aspects of your project. Let’s explore how to manage this without dropping the ball.

Why multiple remotes?

You might wonder, “Why complicate life with multiple remotes?” Well, there are valid reasons:

  • Collaboration: Working with forks of a main project.
  • Backup: Pushing to different hosting services for redundancy.
  • Separation of concerns: Different remotes for different stages or parts of your project.

Adding a remote repository

To start, you need to add a remote repository. Here’s how:

  1. Open your terminal and navigate to your local Git repository.
  2. Add a new remote with a unique name:
    git remote add upstream https://github.com/otheruser/otherrepo.git

    Here, upstream is a common name used for the original project’s repository when you’re working on a fork.

Fetching from multiple remotes

Once you’ve added a new remote, you can fetch its branches:

git fetch upstream

This command gets you all the branches from the upstream repository.

Pushing to different remotes

To push your changes to a different remote, specify the remote name:

git push upstream your-branch

Replace your-branch with the branch you want to push.

Pulling from different remotes

Similarly, to pull updates from a specific remote:

git pull upstream main

This will merge changes from the main branch of the upstream repository into your current branch.

Example output

When adding a remote:

(no output indicates success)

Fetching from a new remote:

remote: Enumerating objects: 26, done.
remote: Counting objects: 100% (26/26), done.
remote: Compressing objects: 100% (20/20), done.
remote: Total 22 (delta 5), reused 12 (delta 2), pack-reused 0
Unpacking objects: 100% (22/22), done.
From https://github.com/otheruser/otherrepo.git
 * [new branch]      main       -> upstream/main

Pushing to a different remote:

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 1.23 KiB | 1.23 MiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/otheruser/otherrepo.git
   a1b2c3d..e4f5g6h  your-branch -> your-branch

Troubleshooting common issues

Sometimes, Git can be a bit finicky. If you encounter an error, don’t panic. It’s usually something simple.

The branch doesn’t exist

If you get an error saying the branch doesn’t exist, double-check the branch name. Typos are the bane of programmers!

Permission issues

If you’re having trouble fetching from the remote, check your permissions. Are you logged into the right account? It’s like trying to enter your house with the wrong key.

My tips

Over my years of using Git, I’ve picked up a few tricks:

    • Stay organized: Regularly delete branches you no longer need. It’s like housekeeping for your repository.
    • Use meaningful names: Naming a branch fix is like naming your pet dog “Dog.” Be descriptive!
    • Regularly pull changes: Keep your local branches updated with git pull. It’s like syncing your watch with the world clock.


Navigating through Git’s complexities can be a challenging yet rewarding journey. From the simplicity of checking out remote branches to the slightly more intricate processes of resolving name clashes and juggling multiple remote repositories, we’ve covered essential strategies to enhance your Git prowess.

The key to mastering Git lies in understanding these fundamental concepts and applying them in your daily development activities. With these tools in your arsenal, you’re well-equipped to tackle the dynamic demands of version control in your projects, ensuring a more organized, efficient, and collaborative coding environment.

You may also like

Leave a Comment



FOSS Linux is a leading resource for Linux enthusiasts and professionals alike. With a focus on providing the best Linux tutorials, open-source apps, news, and reviews written by team of expert authors. FOSS Linux is the go-to source for all things Linux.

Whether you’re a beginner or an experienced user, FOSS Linux has something for everyone.

Follow Us


©2016-2023 FOSS LINUX



“Linux” is the registered trademark by Linus Torvalds in the U.S. and other countries.