> ## Documentation Index
> Fetch the complete documentation index at: https://resources.devweekends.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Google Summer of Code (GSoC)

> The complete guide to getting selected for GSoC — from choosing a project to writing a winning proposal

<Info>
  **TL;DR** — GSoC is a global, paid, remote program where contributors work on real open-source projects under expert mentorship for 10–22 weeks. Google pays the stipend. You don't need to be a student anymore — self-taught developers and recent grads are eligible too.
</Info>

## What is GSoC?

Google Summer of Code connects **beginner-to-intermediate developers** with open-source organizations. Each year, Google funds contributors to spend their summer (or any 10–22 week window) writing code for a participating org. You get:

* A **real-world codebase** to work on — not a toy project
* A dedicated **mentor** from the organization
* A **stipend** from Google (adjusted by your country)
* A line on your resume that recruiters actually recognize

Since 2005, GSoC has brought in **19,000+ contributors** from 112 countries, producing **43 million+ lines** of open-source code.

## Who Can Apply?

You're eligible if you are:

* **18 years or older** at the time of registration
* A **new or beginner open-source contributor** (no prior GSoC acceptance)
* **Eligible to work** in your country of residence
* **Not** an organization admin or mentor for the same cycle

Eligible roles include students, self-taught developers, coding bootcamp graduates, recent university graduates (within 6 months), and people returning to tech.

<Warning>
  You do **not** need to be enrolled in a university. GSoC dropped the "student-only" restriction in 2022.
</Warning>

## Timeline (Typical Annual Cycle)

The exact dates shift each year, but the overall flow stays the same.

| Phase                             | Approximate Timing      | What Happens                                          |
| --------------------------------- | ----------------------- | ----------------------------------------------------- |
| Org applications                  | January                 | Organizations apply to participate                    |
| Orgs announced                    | February                | Google publishes the list of accepted orgs            |
| **Contributor applications open** | **Mid-March**           | You submit proposals to orgs                          |
| Contributor applications close    | Early April             | Deadline for all proposals                            |
| Accepted contributors announced   | Early May               | Google publishes the results                          |
| Community bonding                 | May (2–3 weeks)         | Meet your mentor, set up dev environment              |
| Coding period                     | June – August           | Build your project                                    |
| Midterm evaluation                | Mid-July                | Mentor evaluates your progress (triggers 45% stipend) |
| Final evaluation                  | Late August – September | Submit final work (triggers remaining 55% stipend)    |

<Tip>
  Always check the [official GSoC timeline](https://developers.google.com/open-source/gsoc/timeline) — dates change every year.
</Tip>

## Stipends

GSoC uses **Purchasing Power Parity (PPP)** to adjust stipends by country. Payments are made via Payoneer.

| Project Size | Hours/Week        | Duration    | Stipend Range   |
| ------------ | ----------------- | ----------- | --------------- |
| Small        | \~90 hours total  | 10–22 weeks | $750 – $1,650   |
| Medium       | \~175 hours total | 10–22 weeks | $1,500 – $3,300 |
| Large        | \~350 hours total | 10–22 weeks | $3,000 – $6,600 |

**Examples (medium project):**

* Pakistan, India, Bangladesh → \~\$1,500
* Turkey, Mexico, Poland → \~$1,800–$2,100
* Germany, UK, France → \~\$2,700
* USA, Canada, Australia → \~\$3,300

Payments are split: **45% after midterm** evaluation and **55% after final** evaluation.

## Step-by-Step: How to Get Selected

### Phase 1: Explore Organizations (2–3 months before apps open)

<Steps>
  <Step title="Browse the org list">
    Once organizations are announced (usually February), visit [summerofcode.withgoogle.com](https://summerofcode.withgoogle.com/) and browse the list. Filter by technology, topic, or language.
  </Step>

  <Step title="Shortlist 3–5 organizations">
    Pick orgs that match your skills **and** interest you. Don't just chase "easy" projects.
  </Step>

  <Step title="Read their Ideas Page">
    Every org publishes a list of project ideas. Read all of them. Note which ones excite you.
  </Step>

  <Step title="Join their communication channels">
    Most orgs use Slack, Discord, IRC, or mailing lists. Introduce yourself, ask questions, and start lurking.
  </Step>
</Steps>

### Phase 2: Start Contributing (Before Applications Open)

This is the **most important phase**. Orgs strongly prefer contributors who have already shown up.

<Steps>
  <Step title="Set up the development environment">
    Clone the repo, build the project locally, run the tests. Document any setup issues you encounter — this itself can be a contribution.
  </Step>

  <Step title="Pick a 'good first issue'">
    Most orgs label beginner-friendly issues. Start there. Even fixing a typo in docs counts.
  </Step>

  <Step title="Submit a pull request">
    Get at least 1–2 merged PRs before the application window opens. This shows you can work with their codebase and follow their contribution guidelines.
  </Step>

  <Step title="Engage with mentors">
    Ask thoughtful questions about the project idea you're targeting. Understand the scope, technical challenges, and what the mentor expects.
  </Step>
</Steps>

### Phase 3: Write a Killer Proposal

Your proposal is the **single most important factor** in selection. Here's the structure that works:

#### Proposal Template

```markdown theme={null}
## 1. Contact Information
- Name, email, GitHub, timezone, university (if applicable)

## 2. Synopsis
- 2–3 sentence summary of what you'll build and why it matters

## 3. About Me
- Relevant skills, past projects, open-source experience
- Link to your PRs/contributions to this org

## 4. Project Description
- Detailed technical approach
- What technologies/libraries you'll use
- How your work integrates with the existing codebase

## 5. Timeline & Milestones
- Week-by-week breakdown
- Clear deliverables for midterm and final evaluation
- Buffer time for unexpected issues

## 6. Availability
- Hours per week you'll dedicate
- Any conflicts (exams, travel, other commitments)
- Be honest — mentors appreciate transparency

## 7. Why This Project?
- What draws you to this org and this specific idea
- How it aligns with your goals
```

<Warning>
  **Common mistakes that get proposals rejected:**

  * Copy-pasting the project idea description without adding your own analysis
  * Unrealistic timelines (too much in too little time)
  * No prior contributions to the organization
  * Vague technical approach ("I will implement the feature")
  * Applying to 10+ orgs with generic proposals
</Warning>

### Phase 4: After Acceptance

<Steps>
  <Step title="Community bonding (2–3 weeks)">
    Set up your dev environment, agree on communication cadence with your mentor (daily standups? weekly calls?), define the scope clearly, and create a project board or issue tracker.
  </Step>

  <Step title="Coding period">
    Ship code regularly. Don't go silent for days. Push small, reviewable PRs. Ask for feedback early.
  </Step>

  <Step title="Evaluations">
    Your mentor evaluates you at midterm and final. Passing triggers stipend payments. Failing midterm means you're removed from the program.
  </Step>
</Steps>

## Pro Tips from Past GSoC Contributors

1. **Start early -- December or January, not March** — The best contributors have already set up the dev environment, joined communication channels, and submitted 1-2 merged PRs before applications even open. By March, you should be discussing your proposal with mentors, not introducing yourself.
2. **Quality over quantity -- one excellent proposal beats five mediocre ones** — Mentors can immediately tell the difference between a proposal written by someone who understands their codebase and a generic template. Invest 80% of your effort in your top-choice org.
3. **Study past accepted proposals** — Many orgs publish them (check the [265+ proposals repository](https://github.com/devweekends/open-source-proposals)). Pay attention to the level of technical detail, the specificity of timelines, and how they address risk and fallback plans.
4. **Target "hard" projects deliberately** — Projects marked as "hard" or "350 hours" often have fewer applicants but more mentor support. If you can demonstrate relevant skills through early contributions, you face far less competition than on the "easy" projects everyone gravitates toward.
5. **Communicate proactively and visibly** — If you are stuck, say so in the public channel (not just DMs). If you will miss a deadline, flag it early with a revised plan. Mentors evaluate communication skills as heavily as technical skills because GSoC is fundamentally a remote collaboration exercise.
6. **Document your journey publicly** — Write weekly blog posts about your progress, decisions, and things you learned. This serves three purposes: it helps future contributors, demonstrates your communication ability to mentors, and builds your personal portfolio.
7. **Address the "what if things go wrong" question in your proposal** — The strongest proposals include a risk section: "If X takes longer than expected, I will descope Y and prioritize Z." This shows engineering maturity that most applicants lack.

## Resources

| Resource                                 | Link                                                                                                                                   |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| Official Website                         | [summerofcode.withgoogle.com](https://summerofcode.withgoogle.com/)                                                                    |
| Timeline                                 | [developers.google.com/open-source/gsoc/timeline](https://developers.google.com/open-source/gsoc/timeline)                             |
| Stipend Reference                        | [developers.google.com/open-source/gsoc/help/student-stipends](https://developers.google.com/open-source/gsoc/help/student-stipends)   |
| Student Guide                            | [google.github.io/gsocguides/student](https://google.github.io/gsocguides/student/)                                                    |
| Mentor Guide                             | [google.github.io/gsocguides/mentor](https://google.github.io/gsocguides/mentor/)                                                      |
| 265+ Accepted Proposals (GSoC, LFX, SoB) | [github.com/devweekends/open-source-proposals](https://github.com/devweekends/open-source-proposals)                                   |
| Finding the Right Project                | [google.github.io/gsocguides/student/finding-the-right-project](https://google.github.io/gsocguides/student/finding-the-right-project) |

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="Can I apply if I'm not a student?">
    Yes. Since 2022, GSoC is open to anyone who is new to open source — students, self-taught developers, bootcamp grads, career changers, and recent graduates.
  </Accordion>

  <Accordion title="Can I apply to multiple organizations?">
    Yes, you can submit up to **3 proposals** to different organizations. But quality matters more than quantity.
  </Accordion>

  <Accordion title="What programming languages are used?">
    It depends on the organization. You'll find projects in Python, JavaScript, C/C++, Rust, Go, Java, Ruby, and many more. Pick orgs that use languages you're comfortable with.
  </Accordion>

  <Accordion title="Do I need to know the codebase perfectly before applying?">
    No. But you need to demonstrate that you can navigate it. Setting up the project locally, reading the architecture docs, and making a small contribution goes a long way.
  </Accordion>

  <Accordion title="What if I fail the midterm evaluation?">
    You're removed from the program and don't receive further stipend payments. This is rare if you communicate regularly with your mentor.
  </Accordion>

  <Accordion title="Is GSoC remote or on-site?">
    Fully remote. You can work from anywhere in the world.
  </Accordion>
</AccordionGroup>