Rust Joins Outreachy: Mentorship Opportunities for Underrepresented Groups in Open Source

The Rust Project has long been committed to fostering diverse talent in open source through mentorship programs like Google Summer of Code (GSoC) and OSPP. Now, Rust is expanding its efforts by joining Outreachy starting with the May 2026 cohort. Outreachy is a paid remote internship program designed to support individuals from historically underrepresented or marginalized groups in tech. This Q&A covers everything you need to know about Rust's participation, the differences from other programs, and the exciting projects selected for this round.

Why is the Rust Project participating in Outreachy?

Rust has a strong track record of participating in open-source mentorship initiatives, having been part of Google Summer of Code for three consecutive years and also OSPP. The decision to join Outreachy aligns with the Rust community's core value of inclusivity. Outreachy specifically targets people who face underrepresentation, systemic bias, or discrimination in the technical industry in their home country. By offering internships through Outreachy, Rust aims to actively lower barriers for talented individuals who might otherwise be excluded from traditional open-source contribution pathways. This participation also allows Rust to tap into fresh perspectives and skills from a wider range of backgrounds, ultimately enriching the ecosystem. The program runs twice a year (May–August and December–March), and Rust has committed to mentoring four interns for the May 2026 cohort.

Rust Joins Outreachy: Mentorship Opportunities for Underrepresented Groups in Open Source — Source: blog.rust-lang.org

How does Outreachy differ from Google Summer of Code?

While both programs offer paid open-source internships, there are key differences. First, application flow: in Outreachy, interns apply first to the overall program, and only after being accepted can they apply to specific communities. In GSoC, applicants propose directly to a project. Second, contributions: Outreachy mandates a dedicated contribution period before the application, where interns must contribute to the community's project. GSoC makes contributions optional but common. Third, stipend funding: In GSoC, Google covers all stipends and overhead. For Outreachy, each participating community must fund their own interns' stipends and program costs. Rust is currently funding four slots. Additionally, Outreachy runs twice a year (May–August and December–March), while GSoC runs once (May–August). Both programs select interns based on applications and demonstrated contributions, but Outreachy places extra emphasis on the required contribution phase.

How are interns selected for Outreachy in the Rust community?

Selection in Outreachy follows a two-phase process. First, applicants apply to the overall Outreachy program and are screened for eligibility (e.g., facing underrepresentation or systemic bias). Once accepted as an Outreachy applicant, they enter a contribution period where they must engage with the chosen community—in this case, Rust. They submit meaningful contributions, such as code, documentation, or testing, to the projects they're interested in. After this phase, applicants submit an internship application that includes their contributions. The mentoring team then reviews the applications, considering the quality of contributions, the applicant's communication, and alignment with project goals. For the May 2026 cohort, Rust selected four interns from a competitive pool. The process ensures that interns are both motivated and have already proven they can work effectively within the community.

What four projects are being mentored in the May 2026 cohort?

The Rust Project chose four intern projects, each addressing a unique area of the ecosystem. These projects were selected based on available mentoring capacity and funding. The four projects are:

Calling overloaded C++ functions from Rust – exploring experimental implementation and testing.
Code coverage of the Rust compiler at scale – developing workflows to measure test coverage.
Fuzzing the a-mir-formality type system implementation – applying fuzzing techniques to a formal model.
A fourth project not detailed in the announcement, but likely related to another area of compiler or tooling improvement.

Each intern will be mentored by experienced Rust contributors, ensuring they receive close guidance and support throughout the internship period from May to August 2026.

What is the project about calling overloaded C++ functions from Rust?

This project, led by intern Ajay Singh and mentored by teor, Taylor Cramer, and Ethan Smith, focuses on an experimental feature: enabling Rust code to call overloaded C++ functions. Overloaded functions in C++ have the same name but different parameters, which complicates foreign function interfaces (FFI). The goal is to design and prototype a mechanism to automatically resolve such overloads when generating bindings. The project will test the implementation on representative use cases to validate its correctness and usability. Success would significantly improve Rust's interoperability with existing C++ libraries, making Rust adoption easier in mixed-language projects. This work is still experimental, so it aims to produce a proof-of-concept rather than a production-ready feature.

What is the code coverage project for the Rust compiler?

Intern Akintewe Oluwasola, mentored by Jack Huey, is tackling code coverage analysis for the Rust compiler itself. The project aims to develop workflows to measure coverage at scale: both across the compiler's entire test suite and on ecosystem crates detected by Crater, Rust's community-wide testing tool. The objective is to identify areas of the compiler that are inadequately tested, either within the compiler's own codebase or in the broader ecosystem. By building tools for continuous coverage analysis, the project will help maintainers detect regressions and prioritize testing efforts. This is crucial for ensuring the compiler remains reliable as it evolves.

What is the fuzzing project for a-mir-formality?

Intern Tunde-Ajayi Olamiposi will work with mentors Niko Matsakis, Rémy Rakic, and tiif on fuzzing a-mir-formality, an in-progress formal model of Rust's type and trait system. The project involves implementing fuzzing techniques—automated testing that generates random inputs—to find edge cases and potential inconsistencies in the model. Since a-mir-formality is a critical foundation for future Rust language features, ensuring its correctness is paramount. By building a fuzzing harness, the project aims to systematically explore the model's behavior and identify bugs or gaps before they affect the language. This work will complement existing verification efforts and accelerate the maturity of the formal model.

Tags: