This is the badge. Click it to open the interactive 3D globe. The animated GIF rotates on its own so it works as a static profile badge too.

I built a GitHub profile badge that traces contributions to public repositories back to their owners and maps them onto an interactive globe.

Try it yourself

Want your own globe? It takes about two minutes.

1. Fork the repository: https://github.com/turbolego/github-contrib-globe-badge

2. Fork the repository, then the workflow will automatically use your GitHub username to generate the badge. No changes to the workflow are needed.

3. Enable GitHub Pages → Source: Deploy from branch → main / (root)

4. Add this to your profile README:

[![My contributions badge](https://raw.githubusercontent.com/turbolego/github-contrib-globe-badge/main/badge.gif)](https://turbolego.github.io/github-contrib-globe-badge/)

Replace turbolego with your username. GitHub Actions regenerates the badge daily.

Repo: https://github.com/turbolego/github-contrib-globe-badge

Interactive demo: https://turbolego.github.io/github-contrib-globe-badge/

How does it work?

GitHub commits authored by me
         │
         ├── Co-authored-by trailers
         │
         ▼
Resolve true repository origin
         │
         ├── GitHub fork source → follow to ultimate origin
         │
         └── Commits-search fallback → find oldest repo sharing the SHA
         │
         ▼
Repository owner (not the fork owner)
         │
         ▼
GitHub profile location (free-text string)
         │
         ▼
Nominatim geocoding
         │
         ├── Country polygon lookup (primary)
         │
         └── Reverse geocode fallback (coastal / edge cases)
         │
         ▼
Country code + flag
         │
         ▼
┌─────────────────────┬─────────────────────┐
│ badge.gif           │ data.json           │
│ (animated GIF)      │ (Cobe globe data)   │
└─────────┬───────────┴─────────┬───────────┘
          ▼                     ▼
    GitHub README          GitHub Pages
    (static badge)         (interactive Cobe globe)

The entire thing runs on GitHub. No server, no database, no backend API that has to stay running. A daily GitHub Action collects contributions, resolves repository origins, geocodes owners, generates the GIF and JSON, and GitHub Pages serves the interactive globe from the committed data.json.

The surprisingly hard part: where did the contribution actually happen?

The visual is fun, but the engineering is the interesting part.

A contribution might exist in a fork, but you don't necessarily want to attribute it to the person who owns the fork.

Your fork → someone else's repository → original repository → repository owner → owner's location → country on the globe

The project has to resolve the true origin repository for each commit:

1. Follow GitHub's fork source field — if the repo is a registered GitHub fork, walk the fork chain to the ultimate origin.

2. Fall back to commits-search origin detection — when a repository duplicates commit history without being a registered GitHub fork (common when someone seeds a new repo from a full clone of another repo's history), search all public repositories that contain the commit SHA and pick the oldest by creation date.

3. Cache origins per repository — this runs at most once per distinct repository, not once per commit. The cache is persisted across Action runs with a 30-day TTL (a repo that was private can later become public and turn out to be the true older origin).

// Simplified: the core origin resolution logic
const candidates = new Set([fullName]);
// 1. Search all repos containing this commit SHA
const data = await searchCommits(`sha:${sha} is:public`);
for (const item of data.items) candidates.add(item.repository.full_name);
// 2. Expand fork networks
for (const name of candidates) {
  const info = await getRepositoryInfo(name);
  if (info?.fork && info.source?.full_name) candidates.add(info.source.full_name);
}
// 3. Pick oldest by creation date
let oldest = null;
for (const name of candidates) {
  const info = await getRepositoryInfo(name);
  if (info?.created_at && (!oldest || info.created_at < oldestDate)) {
    oldest = name;
  }
}
return oldest || fullName;

What counts as a contribution?

A simple GitHub commit search isn't quite enough. Collaborative commits can contain Co-authored-by: trailers, so I also look for those.

The generator searches:

• Authored commits: author:me is:public -user:me

• Co-authored commits: full-text search for "Co-authored-by: me" then verifies each hit against the actual trailers in the commit message (matching by GitHub noreply address, public profile email, or login name)

This catches contributions to repositories where you weren't the primary author but were credited in the commit message.

Turning a GitHub profile location into a country

GitHub's profile location is free-form user-entered text. That's not a structured address.

Oslo, Norway
Berlin
California
Internet
Earth
Remote

The pipeline handles this:

1. Nominatim forward geocode — convert the string to lat/lon

2. Country polygon lookup — test the point against Natural Earth country polygons (the geo-countries dataset)

3. Reverse geocode fallback — if the point falls outside any polygon (coastal locations, small islands), call Nominatim reverse geocode with zoom=3 to get the country code from the address details

4. Flags — from the MIT-licensed flag-icons library for the animated GIF

// Country lookup with fallback
marker.countryCode = countryCodeAt(marker.location, geojson);
if (!marker.countryCode) {
  // wait for Nominatim rate limit
  await sleep(1100);
  marker.countryCode = await reverseCountryCode(marker.location);
}

Why GitHub Actions?

The Action runs daily at midnight UTC, commits badge.gif + data.json + commit-cache.json back to main, and Pages picks up the new data automatically. Zero infrastructure to maintain.

What my globe looks like

Total tracked: 137 commits, 25 merged PRs across 8 countries.

Limitations

Why I built this

GitHub's contribution graph tells me how much I've contributed.

I started wondering about a different question:

Who are all these contributions actually reaching?

A contribution to an open-source project isn't just an entry on my GitHub graph. It's a connection to another developer, organization, or community somewhere else in the world.

I wanted to visualize that network — not as an abstract chart, but as a literal map. Where does my open-source work actually end up?

What's next?

Things I'd like to explore (no promises):

• Historical animation — scrub through time to watch the globe grow

• Repository-level markers — not just country aggregates

• Organization support — attribute contributions to orgs, not just owners

• Better ambiguous-location handling — disambiguate "Springfield" etc.

• City-level view — zoom in on dense regions

• Contribution types beyond commits/PRs — issues, reviews, discussions

• Interactive repository filtering — click a country, see its repos

• Time-range selection — "last year", "all time", custom range

• Caching/API optimization — smarter search query batching

What does your globe look like?

Fork the project, add the badge to your profile, and see what your globe looks like.

I'm especially curious to see whether anyone gets a more geographically distributed contribution map than mine.

If you find a weird location that the geocoder gets wrong, open an issue or let me know in the comments.

Where does your open-source work take you?

GitHub repository: https://github.com/turbolego/github-contrib-globe-badge

Interactive demo: https://turbolego.github.io/github-contrib-globe-badge/