SVN uses a single centralized repository to serve as the communication hub for developers, and collaboration takes place by passing changesets between the developers’ working copies and the central repository. This is different from Git's distributed collaboration model, which gives every developer their own copy of the repository, complete with its own local history and branch structure. Users typically need to share a series of commits rather than a single changeset. Instead of committing a changeset from a working copy to the central repository, Git lets you share entire branches between repositories.
git remote command is one piece of the broader system which is responsible for syncing changes. Records registered through the
git remote command are used in conjunction with the
git push, and
git pull commands. These commands all have their own syncing responsibilities which can be explored on the corresponding links.
git remote command lets you create, view, and delete connections to other repositories. Remote connections are more like bookmarks rather than direct links into other repositories. Instead of providing real-time access to another repository, they serve as convenient names that can be used to reference a not-so-convenient URL.
For example, the following diagram shows two remote connections from your repo into the central repo and another developer’s repo. Instead of referencing them by their full URLs, you can pass the origin and john shortcuts to other Git commands.
Git remote usage overview
git remote command is essentially an interface for managing a list of remote entries that are stored in the repository's
./.git/config file. The following commands are used to view the current state of the remote list.
Viewing git remote configurations
List the remote connections you have to other repositories.
git remote -v
Same as the above command, but include the URL of each connection.
Creating and modifying git remote configurations
git remote command is also a convenience or 'helper' method for modifying a repo's
./.git/config file. The commands presented below let you manage connections with other repositories. The following commands will modify the repo's
/.git/config file. The result of the following commands can also be achieved by directly editing the
./.git/config file with a text editor.
git remote add <name> <url>
Create a new connection to a remote repository. After adding a remote, you’ll be able to use
＜name＞ as a convenient shortcut for
＜url＞ in other Git commands.
git remote rm <name>
Remove the connection to the remote repository called
git remote rename <old-name> <new-name>
Rename a remote connection from
Git remote discussion
Git is designed to give each developer an entirely isolated development environment. This means that information is not automatically passed back and forth between repositories. Instead, developers need to manually pull upstream commits into their local repository or manually push their local commits back up to the central repository. The
git remote command is really just an easier way to pass URLs to these "sharing" commands.
The origin Remote
When you clone a repository with
git clone, it automatically creates a remote connection called origin pointing back to the cloned repository. This is useful for developers creating a local copy of a central repository, since it provides an easy way to pull upstream changes or publish local commits. This behavior is also why most Git-based projects call their central repository origin.
Git supports many ways to reference a remote repository. Two of the easiest ways to access a remote repo are via the HTTP and the SSH protocols. HTTP is an easy way to allow anonymous, read-only access to a repository. For example:
But, it’s generally not possible to push commits to an HTTP address (you wouldn’t want to allow anonymous pushes anyways). For read-write access, you should use SSH instead:
You’ll need a valid SSH account on the host machine, but other than that, Git supports authenticated access via SSH out of the box. Modern secure 3rd party hosting solutions like Bitbucket.com will provide these URLs for you.
Git remote commands
git remote command is one of many Git commands that takes additional appended 'subcommands'. Below is an examination of the commonly used
git remote subcommands.
ADD <NAME> <URL>
Adds a record to
./.git/config for remote named
＜name＞ at the repository url
-f option, that will
git fetch immediately after the remote record is created.
--tags option, that will
git fetch immediately and import every tag from the remote repository.
RENAME <OLD> <NEW>
./.git/config to rename the record
＜NEW＞. All remote-tracking branches and configuration settings for the remote are updated.
REMOVE or RM <NAME>
./.git/config and removes the remote named
＜NAME＞. All remote-tracking branches and configuration settings for the remote are removed.
Outputs the URLs for a remote record.
--push, push URLs are queried rather than fetch URLs.
--all, all URLs for the remote will be listed.
Outputs high-level information about the remote
Deletes any local branches for
＜NAME＞ that are not present on the remote repository.
--dry-run option which will list what branches are set to be pruned, but will not actually prune them.
Git remote examples
In addition to origin, it’s often convenient to have a connection to your teammates’ repositories. For example, if your co-worker, John, maintained a publicly accessible repository on
dev.example.com/john.git, you could add a connection as follows:
git remote add john http://dev.example.com/john.git
Having this kind of access to individual developers’ repositories makes it possible to collaborate outside of the central repository. This can be very useful for small teams working on a large project.
Showing your remotes
By default, the
git remote command will list previously stored remote connections to other repositories. This will produce single line output that lists the names of "bookmark" name of remote repos.
$ git remote
git remote with the
-v option will print the list of bookmarked repository names and additionally, the corresponding repository URL. The
-v option stands for "verbose". Below is example output of verbose
git remote output.
git remote -v
origin email@example.com:origin_user/reponame.git (fetch)
origin firstname.lastname@example.org:origin_user/reponame.git (push)
upstream https://bitbucket.com/upstream_user/reponame.git (fetch)
upstream https://bitbucket.com/upstream_user/reponame.git (push)
other_users_repo https://bitbucket.com/other_users_repo/reponame (fetch)
other_users_repo https://bitbucket.com/other_users_repo/reponame (push)
Adding Remote Repositories
git remote add command will create a new connection record to a remote repository. After adding a remote, you’ll be able to use
./.git/config. An example of this config file update follows:
$ git remote add fake_test https://bitbucket.com/upstream_user/reponame.git; [remote "remote_test"]
url = https://bitbucket.com/upstream_user/reponame.git
fetch = +refs/heads/*:refs/remotes/remote_test/*
Inspecting a Remote
The show subcommand can be appended to
git remote to give detailed output on the configuration of a remote. This output will contain a list of branches associated with the remote and also the endpoints attached for fetching and pushing.
git remote show upstream
* remote upstream
Fetch URL: https://bitbucket.com/upstream_user/reponame.git
Push URL: https://bitbucket.com/upstream_user/reponame.git
HEAD branch: main
Local ref configured for 'git push':
main pushes to main (fast-forwardable)
Fetching and pulling from Git remotes
Once a remote record has been configured through the use of the
git remote command, the remote name can be passed as an argument to other Git commands to communicate with the remote repo. Both
git fetch, and
git pull can be used to read from a remote repository. Both commands have different operations that are explained in further depth on their respective links.
Pushing to Git remotes
git push command is used to write to a remote repository.
git push <remote-name> <branch-name>
This example will upload the local state of
＜branch-name＞ to the remote repository specified by
Renaming and Removing Remotes
git remote rename <old-name> <new-name>
git remote rename is self-explanatory. When executed, this command will rename a remote connection from
＜new-name＞. Additionally, this will modify the contents of
./.git/config to rename the record for the remote there as well.
git remote rm <name>
git remote rm will remove the connection to the remote repository specified by the
＜name＞ parameter. To demonstrate let us 'undo' the remote addition from our last example. If we execute
git remote rm remote_test, and then examine the contents of
./.git/config we can see that the
[remote "remote_test"] record is no longer there.