Your first open source contribution starts here.

Open source software is code that anyone can read, use, modify, and improve. Projects like Linux, VS Code, React, and Python were all built collaboratively by thousands of contributors around the world, many of whom started exactly where you are right now.

When you contribute to open source, you're not just writing code. You're learning to read large codebases, communicate with engineers, follow conventions, and ship work that real people depend on. That's why recruiters love it.

Git is the version-control tool that powers open source. Think of it as a "save game" system for code, every change is tracked, reversible, and shareable.

Windows

1. Go to git-scm.com/download/win and download the installer.
2. Run the installer with default settings (just keep clicking Next).
3. Open Git Bash from your Start menu when done.

macOS

Open Terminal and run:

Copy# Easiest way, installs Apple's command line tools (includes git)
xcode-select --install

Linux (Ubuntu/Debian)

Copysudo apt update && sudo apt install git -y

Verify it worked

Copygit --version
# Expected output: git version 2.x.x

GitHub is where the world's open-source code lives. Your GitHub profile is your developer resume, make it count.

1. Sign up at github.com/join. Pick a clean, professional username, recruiters will see it.
2. Add a real photo, your real name, and a short bio. Empty profiles look like spam accounts.
3. Verify your email, GitHub blocks PRs from unverified accounts.
4. Connect Git on your computer to GitHub by setting your identity:

Copygit config --global user.name "Your Name"
git config --global user.email "you@example.com"
# Use the SAME email you signed up to GitHub with

Set up SSH (recommended, do this once)

SSH lets you push code without typing your password every time.

Copy# 1. Generate a new SSH key
ssh-keygen -t ed25519 -C "you@example.com"

# 2. Copy the public key (Linux/Mac)
cat ~/.ssh/id_ed25519.pub

Then go to GitHub → Settings → SSH and GPG keys and paste the key.

You don't need to memorize all of Git. 95% of contributing to open source uses just these seven commands. Master these and you're set.

Copy# 1. Clone, download a project to your computer
git clone git@github.com:user/project.git

# 2. Status, see what files you've changed
git status

# 3. Branch, start working on a new feature without breaking main
git checkout -b fix/typo-in-readme

# 4. Add, stage changes you want to save
git add README.md
# or stage everything you changed:
git add .

# 5. Commit, save a snapshot with a clear message
git commit -m "docs: fix typo in installation section"

# 6. Push, upload your branch to GitHub
git push origin fix/typo-in-readme

# 7. Pull, get the latest changes from the remote
git pull origin main

Don't randomly clone a giant repo and try to fix something hard. Maintainers literally tag beginner-friendly tasks for you.

• On any GitHub repo, click Issues → filter by labels like good first issue, help wanted, beginner-friendly, or documentation.
• Read the issue carefully. Comment something like: "Hi! I'd like to work on this. Can I be assigned?" Wait for confirmation before starting.
• For SSoC participants, browse curated SSoC Season 5 projects, every project lists its beginner tasks and a mentor you can reach out to.

What makes a great first contribution?

• Documentation fixes, typos, broken links, missing examples. Easy wins.
• Small bugs, something behaves differently than the README says.
• Tests, adding tests for existing functions teaches you the codebase fast.

A fork is your personal copy of someone else's project. You make changes on your fork, then ask the original maintainer to pull them in.

1. Click the Fork button on the project's GitHub page (top-right). This creates github.com/YOU/project.
2. Clone your fork (not the original):

Copygit clone git@github.com:YOU/project.git
cd project

# Add the original project as "upstream" so you can sync later
git remote add upstream git@github.com:original-owner/project.git

# Always create a new branch, never work on main directly
git checkout -b fix/issue-42-broken-link

# ... make your changes in your editor ...

git add .
git commit -m "docs: fix broken link in setup guide (#42)"
git push origin fix/issue-42-broken-link

Writing commit messages that don't get rejected

• Bad: "updated stuff", "final fix pls merge", "asdfasdf"
• Good: "fix: handle empty input in login form"
• Great: Short title (≤ 50 chars), then a blank line, then 1–2 sentences explaining why.

A Pull Request (PR) is the formal request for the maintainer to merge your changes. This is the moment you officially become an open source contributor.

1. After pushing, GitHub shows a yellow banner saying "Compare & pull request". Click it.
2. Set the base repo to the original project, not your fork.
3. Write a clear title and description. Reference the issue: Closes #42 auto-links it.
4. Submit. A bot (or maintainer) will run tests and review.
5. Be patient. Maintainers are volunteers. If there's no reply in 7+ days, post one polite follow-up comment.
6. If they request changes, just commit again on the same branch and push, the PR updates automatically.

A PR description that gets merged

Copy## What this does
Fixes the broken installation link in README.md
that pointed to an old domain.

## Why
Closes #42. Users were getting 404s when trying
to follow the setup guide.

## Testing
- Verified the new link opens correctly
- Ran npm test locally, all 28 tests pass

## Screenshots
(attach before/after if it's a UI change)

Bookmark this. You'll use it for the next decade.

Copy# --- Setup (once) ---
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# --- Daily workflow ---
git status                             # what's changed?
git diff                               # see the actual changes
git add file.js                       # stage one file
git add .                              # stage everything
git commit -m "feat: add login button"
git log --oneline                     # history of commits

# --- Branches ---
git branch                             # list branches
git checkout -b feature/dark-mode     # create + switch
git checkout main                     # switch back
git merge feature/dark-mode           # merge into current

# --- Sync with the original (upstream) ---
git fetch upstream
git merge upstream/main

# --- Undo (carefully!) ---
git restore file.js                  # discard local changes
git reset HEAD~1                      # undo last commit (keep changes)
git revert <commit-hash>              # safely undo a pushed commit

# --- Remote ---
git push origin my-branch
git pull origin main
git remote -v                          # list remotes

Open source is a community. How you communicate matters as much as the code.

Do

• Read the project's CONTRIBUTING.md and README.md before opening an issue.
• Comment on an issue and wait to be assigned before working on it.
• Keep PRs small and focused. One issue = one PR.
• Be polite, patient, and grateful. Maintainers do this in their free time.
• If your PR is closed, ask why politely, every "no" is a free lesson.

Don't

• Don't open empty or duplicate issues. Search existing issues first.
• Don't spam "any update?" comments. Wait at least a week.
• Don't submit PRs that fix typos in README just to farm contributions, many SSoC projects explicitly reject these.
• Don't push directly to main. Always branch.
• Don't share your SSH private key, .env files, or API tokens, ever.

Curated, actually-good, all free. Pick one and finish it.