In je lokale kloon van je gevorkte repository, kun je de originele GitHub repository toevoegen als een "remote" ("Remotes" zijn een soort bijnamen voor de URLs van repositories - origin is er een, bijvoorbeeld). Dan kun je alle branches van die upstream repository ophalen, en je werk rebasen om verder te werken aan de upstream versie. In termen van commando's zou dat er zo uit kunnen zien:

# Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:

git fetch upstream

# Make sure that you're on your master branch:

git checkout master

# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:

git rebase upstream/master

Als je de geschiedenis van je master branch niet wilt herschrijven, (bijvoorbeeld omdat andere mensen hem misschien gekloond hebben) dan zou je het laatste commando moeten vervangen door git merge upstream/master. Echter, om verdere pull requests te maken die zo schoon mogelijk zijn, is het's waarschijnlijk beter om te rebasen.

Als je je branch gerebased hebt op upstream/master, moet je misschien de push forceren om het naar je eigen gevorkte repository op GitHub te pushen. Je zou dat kunnen doen met:

git push -f origin master

Je hoeft de -f alleen de eerste keer te gebruiken nadat je ge-rebased hebt.

Vanaf mei 2014 is het mogelijk om een fork direct vanaf GitHub te updaten. Dit werkt nog steeds vanaf september 2017, MAR het zal leiden tot een vuile commit geschiedenis.

1. Open je fork op GitHub.
2. Klik op Pull Requests.
3. Klik op New Pull Request. Standaard zal GitHub het origineel met je fork vergelijken, en er zou'niets te vergelijken moeten zijn als je geen veranderingen hebt aangebracht.
4. Klik op switching the base als je die link ziet. Anders, stel handmatig de base fork drop down in op jouw fork, en de head fork op de upstream. Nu zal GitHub je vork vergelijken met het origineel, en je zou alle laatste veranderingen moeten zien.
5. Create pull request en wijs een voorspelbare naam toe aan je pull request (bijv. Update from original).
6. Scroll naar beneden naar Merge pull request, maar klik nog nergens op'/kbd&gt.

Nu heb je drie opties, maar elke zal leiden tot een minder-dan-schone commit geschiedenis.

1. De standaard zal een lelijke samenvoeg commit maken.
2. Als je op de dropdown klikt en kiest voor "Squash and merge", dan zullen alle tussenliggende commits in één geplet worden. Dit is meestal iets wat je niet'wilt.
3. Als je klikt op Rebase and merge, zullen alle commits worden gemaakt "with" you, de originele PRs zullen linken naar jouw PR, en GitHub zal This branch is X commits ahead, Y commits behind weergeven.

Dus ja, je kunt je repo up to date houden met zijn upstream door de GitHub web UI te gebruiken, maar als je dat doet zal je je commit geschiedenis bezoedelen. Blijf in plaats daarvan bij de commandoregel - het'is gemakkelijk.

Hier is het officiële document van GitHub's over Een vork synchroniseren:

Synchroniseren van een vork

De setup

Voordat je kunt synchroniseren, moet je een remote toevoegen die naar de upstream repository wijst. Je hebt dit misschien al gedaan toen je de forked maakte.

Tip: Je fork synchroniseren werkt alleen je lokale kopie van de repository bij; het werkt je repository op GitHub niet bij.

$ git remote -v

Lijst van de huidige remotes

origin  https://github.com/user/repo.git (fetch)
origin  https://github.com/user/repo.git (push)

$ git remote add upstream https://github.com/otheruser/repo.git

Stel een nieuwe remote in

$ git remote -v

Verifieer nieuwe remote

origin    https://github.com/user/repo.git (fetch)
origin    https://github.com/user/repo.git (push)
upstream  https://github.com/otheruser/repo.git (fetch)
upstream  https://github.com/otheruser/repo.git (push)

Synchroniseren

Er zijn twee stappen nodig om je repository met de upstream te synchroniseren: eerst moet je van de remote halen, dan moet je de gewenste branch in je lokale branch samenvoegen.

Fetching

Fetchen van het remote repository zal zijn branches en hun respectievelijke commits binnenhalen. Deze worden opgeslagen in je lokale repository onder speciale branches.

$ git fetch upstream

Pak de upstream remote's branches

remote: Counting objects: 75, done.
remote: Compressing objects: 100% (53/53), done.
remote: Total 62 (delta 27), reused 44 (delta 9)
Unpacking objects: 100% (62/62), done.
From https://github.com/otheruser/repo
 * [new branch]      master     -> upstream/master

We hebben nu de upstream's master branch opgeslagen in een lokale branch, upstream/master

$ git branch -va

Lijst van alle lokale en remote-tracking branches

* master                  a422352 My local commit
  remotes/origin/HEAD     -> origin/master
  remotes/origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit

Merging

Nu dat we de upstream repository hebben opgehaald, willen we de wijzigingen samenvoegen in onze lokale branch. Dit zal die branch in sync brengen met de upstream, zonder onze lokale wijzigingen te verliezen.

$ git checkout master

Bekijk onze lokale master branch

Switched to branch 'master'

$ git merge upstream/master

Merge upstream's master in onze eigen

Updating a422352..5fdff0f
Fast-forward
 README                    |    9 -------
 README.md                 |    7 ++++++
 2 files changed, 7 insertions(+), 9 deletions(-)
 delete mode 100644 README
 create mode 100644 README.md

Als je lokale branch geen unieke commits had, zal git in plaats daarvan een "fast-forward" uitvoeren:

$ git merge upstream/master Bijwerken van 34e91da..16c56ad Fast-forward README.md | 5 +++ 1 bestand gewijzigd, 3 toevoegingen(+), 2 verwijderingen(-)

Tip: Als je je repository op GitHub wilt updaten, volg dan de instructies hier