Godot’s Usage on GitHub: A Deeper Look at the Stats

Godot’s Usage on GitHub: A Deeper Look at the Stats

Estimated Reading Time: 9 minutes

• Godot’s remarkable growth is fueled by a vast and diverse open-source community, extending far beyond code contributors to include documentation writers, testers, translators, and financial supporters.
• Over a decade, Godot has accumulated over 100,000 issues and pull requests on GitHub, with 2,800 unique code contributors, showcasing an intensely active development ecosystem.
• The project proactively manages its substantial issue backlog through “spring cleaning” initiatives and aims to improve workflows to enhance issue quality and onboard more bug triagers.
• Community engagement in re-assessing, validating, and testing issues and pull requests is crucial for maintaining development momentum and ensuring the engine’s quality.
• Godot consistently receives around 600 new pull requests monthly, indicating a continuous flow of contributions that necessitate dedicated review efforts from the core team and community alike.

• The Phenomenal Growth of Godot: A Community Achievement
• Navigating Godot’s GitHub: Issues and Insights
  • Understanding Godot’s Issue Landscape
  • Empowering the Community: Your Role in Issue Triage
• The Engine of Progress: Understanding Pull Requests
• Conclusion
• Frequently Asked Questions

This blog post was originally posted on GH-100000.

It’s been over 10 years now that Godot has been developed in the open, with code contributions from 2,800 users.
The total count of people who helped build Godot is actually far greater, as it should include documentation writers, testers, bug reporters, translators, moderators, content creators, users doing community support or talking at events, folks making games that credit Godot visibly, everyone supporting the project financially, and many other types of contributions which I can’t keep enumerating.
All these people brought Juan and Ariel’s little-engine-that-could from this:

To this:

That’s no small achievement, so I encourage all contributors to take a minute to contemplate the progress that we’ve made together over this journey so far!
Amidst the daily churn of fixing issues, reviewing PRs, making releases, etc., it’s important to remind ourselves of where we are, and how we got there.

Some stats about Godot usage on GitHub
Between our usual traditions of either making silly jokes or sharing some inspiring stats for round issue numbers, I picked the latter for this 100,000th issue, and wanted to look a bit closer at our issue and PR numbers over time.
A lot of people coming to Godot’s repository to see over 10,000 open issues and 3,000 open PRs might rightfully wonder whether this is normal, or a sign of a maintenance issue. I will make the case that it is a bit of both 🙂
I’ll make a quick note that 100,000 is the combined number of issues and PRs, which share the same index system on GitHub. At the time of writing, we’ve actually had 53,648 issues and 45,213 PRs created. Astute minds will notice that the sum is not 100,000; the difference comes from spam issues or PRs which have been deleted by GitHub. ↩

By Rémi Verschelde

The journey of Godot Engine, from a humble “little-engine-that-could” to a robust and widely-used game development platform, is a testament to the power of open-source collaboration. This incredible transformation, highlighted by projects like PVKK: Planetenverteidigungskanonenkommandant, is underpinned by a vibrant community whose collective efforts extend far beyond mere code contributions. Understanding the scale and dynamics of this community often leads us to its central hub: GitHub. While the raw numbers of issues and pull requests might initially seem daunting, a deeper dive reveals a well-managed, albeit continuously challenged, ecosystem of development.

The Phenomenal Growth of Godot: A Community Achievement

As the verbatim quote from GH-100000 powerfully illustrates, Godot’s ascent is not just about the 2,800 individuals who have contributed code over the past decade. It encompasses a vast network of individuals whose diverse talents weave the very fabric of the project. From documentation specialists ensuring clarity, to bug reporters meticulously identifying glitches, to translators making Godot accessible globally, every role is crucial. Even those who simply create games and visibly credit Godot, or support the project financially, contribute to its enduring legacy and future growth. This expansive, multi-faceted engagement is what truly defines Godot’s remarkable evolution.

This holistic view of contribution is vital when assessing the health of an open-source project. It’s not just the lines of code, but the entire human infrastructure that allows a project to flourish and transition from its nascent stages to a mature, feature-rich engine like Godot 4.3. Recognizing this collective achievement helps contextualize the seemingly overwhelming numbers we often encounter on platforms like GitHub.

Navigating Godot’s GitHub: Issues and Insights

Upon visiting the Godot Engine repository on GitHub, many might be struck by the sheer volume of activity: thousands of open issues and pull requests. This sight often sparks a legitimate question: Is this a sign of a healthy, active project, or a potential maintenance burden? As the project lead Rémi Verschelde insightfully points out, it’s a bit of both.

Understanding Godot’s Issue Landscape

With 53,648 issues created over its lifetime, and approximately 11,000 currently open (around 20%), Godot’s issue backlog falls within a “fairly normal percentage” for software projects of its scale. However, “normal” doesn’t mean “ideal.” The project actively strives for improvement. Key development events, such as the initial beta phases or stable releases, naturally trigger peaks in bug reports, while concerted “spring cleaning” efforts lead to significant drops in open issues.

For instance, around the 3.2 release, a coordinated maintainer effort dramatically reduced open issues from 29% to 19%. A similar “spring cleaning” is being prepared for issues reported during the early days of Godot 4.0 and 4.1, many of which may no longer be relevant with the advent of 4.3 and upcoming 4.4 beta. This proactive approach demonstrates a commitment to managing the backlog effectively. The challenge lies in the steady increase in issue volume versus the slower growth of active bug triagers. To address this, the Godot team is developing improved workflows, aiming to onboard new volunteers, distribute the workload more efficiently, and enhance the overall quality of open issues.

Empowering the Community: Your Role in Issue Triage

While the core team works on refining processes, every community member can significantly contribute to a healthier issue tracker. These three actionable steps can make a real difference:

1. Regularly Re-assess Your Own Issues: Take the time to revisit any bugs or feature requests you’ve reported. Verify if they are still reproducible in the latest stable or development versions of Godot. Critically, ensure a minimal reproduction project is attached. If an issue is no longer relevant or has been implicitly fixed, close it with a brief explanation.
2. Test and Validate Others’ Issues: Extend the same diligent process to other issues you encounter, especially older ones. If you can test an issue and find it’s no longer reproducible in a current Godot version, leave a comment indicating your findings. This valuable feedback alerts bug triagers and helps them determine if the issue can be closed.
3. Contribute to Pull Request Reviews: While less direct for issue triage, reviewing pull requests (PRs) is crucial. Testing an open PR for its functionality, stability, and adherence to design principles provides invaluable feedback. Even if you’re not a core developer, your input can help catch bugs early and accelerate the review process.

A Real-World Example: Imagine a Godot user named Clara encounters a visually perplexing UI bug. She reports it with a clear description and a minimal project. Months later, another user, David, tests a new Godot beta and finds the bug fixed as a side effect of another change. David comments on Clara’s issue, confirming it’s no longer reproducible. This simple act saves a Godot triager precious time they would have spent reproducing the now-resolved bug, allowing them to focus on active, critical issues. This collaborative validation is the bedrock of efficient open-source maintenance.

The Engine of Progress: Understanding Pull Requests

Godot’s development rhythm is also dictated by a substantial volume of pull requests. The project receives roughly 600 new PRs each month, a figure comparable to new issues. This represents an incredible amount of contributed work and proposed enhancements.

Historically, the PR volume surged significantly during the Godot 4.0 development cycle, topping 700 PRs monthly. While it has since plateaued to around 500-600 per month, this still represents a continuous influx of modifications and features. Managing this volume is challenging for a relatively small group of core reviewers, especially as the size and complexity of PRs appear to be on an upward trend. The review process for such a widely used engine often requires careful consideration for compatibility and API design, naturally extending review times. More community involvement in testing and reviewing these daily contributions is therefore essential to maintain momentum and ensure quality.

Conclusion

Godot Engine’s journey on GitHub is a dynamic narrative of growth, community, and continuous improvement. The statistics, from thousands of issues to hundreds of monthly pull requests, paint a picture of a project that is both immensely popular and actively developed. While the sheer volume of activity might initially suggest an overwhelming backlog, a closer look reveals dedicated efforts to manage these challenges through strategic “spring cleanings,” improved workflows, and the invaluable contributions of its expansive community. The “little-engine-that-could” has blossomed into a formidable force, and its continued success hinges on the collective spirit of those who contribute in myriad ways.

Frequently Asked Questions

• How many people have contributed code to Godot Engine?
• What types of contributions are valued in the Godot community beyond code?
• Is the high number of open issues on Godot’s GitHub repository normal?
• How does Godot manage its issue backlog?
• What can community members do to help with Godot’s issue triage?
• How many new pull requests does Godot receive monthly?
• Why is community involvement in PR reviews important for Godot?

How many people have contributed code to Godot Engine?

Over 2,800 users have contributed code to the Godot Engine over the past 10 years of its open development.

What types of contributions are valued in the Godot community beyond code?

The Godot community values a wide range of contributions, including documentation writing, testing, bug reporting, translation, moderation, content creation, community support, speaking at events, making games that credit Godot, and financial support.

Is the high number of open issues on Godot’s GitHub repository normal?

With approximately 11,000 open issues out of 53,648 created (around 20%), the percentage of open issues is considered “fairly normal” for a software project of Godot’s scale. However, the project continuously strives to improve its management.

How does Godot manage its issue backlog?

Godot manages its issue backlog through strategic “spring cleaning” efforts by maintainers, particularly after major releases. They are also developing improved workflows to onboard new volunteers, distribute workload efficiently, and enhance issue quality.

What can community members do to help with Godot’s issue triage?

Community members can help by regularly re-assessing their own reported issues (verifying reproducibility and adding minimal reproduction projects), testing and validating other users’ issues, and contributing to pull request reviews.

How many new pull requests does Godot receive monthly?

Godot receives roughly 600 new pull requests each month, indicating a high volume of proposed enhancements and code contributions.

Why is community involvement in PR reviews important for Godot?

Community involvement in PR reviews is crucial because it provides invaluable feedback on functionality, stability, and adherence to design principles. This helps catch bugs early, accelerates the review process, and maintains the quality of the engine given the large volume of incoming PRs.