The Rust Project has a strong tradition of supporting open-source mentorship initiatives, having participated in Google Summer of Code for three consecutive years and previously in OSPP. We're pleased to announce that starting with the May 2026 cohort, Rust will also take part in Outreachy. This program targets individuals from underrepresented and marginalized groups in tech, offering paid internships to foster diversity and inclusion. Below, we answer common questions about Outreachy and Rust's involvement.
What is Outreachy and how does it differ from Google Summer of Code?
Outreachy is an open-source internship program for people who face underrepresentation, systemic bias, or discrimination in the tech industry. While similar to Google Summer of Code (GSoC) in offering remote internships, there are key differences. First, Outreachy requires applicants to be accepted into the overall program before they can apply to individual communities—unlike GSoC where you apply directly to a project. Second, Outreachy has a dedicated contribution period during which candidates must make meaningful contributions to the community's codebase or documentation as part of their application. While GSoC also encourages contributions, they aren't mandatory. Third, internship stipends for Outreachy are funded directly by the participating communities, whereas Google covers stipends and overhead for GSoC. Outreachy runs two internship cycles per year: May–August and December–March. The Rust Project is participating in the May 2026 cohort.
Why is the Rust Project participating in Outreachy this year?
The Rust Project values diversity and inclusion as core principles. After several successful years with Google Summer of Code, we recognized that Outreachy's mission aligns closely with our goal to lower barriers for newcomers from underrepresented backgrounds. By joining Outreachy, we can directly support individuals who face unique challenges in entering the tech industry, while also bringing fresh perspectives to our ecosystem. The program's requirement for substantial contributions before selection ensures that interns are well-prepared to succeed, and our experienced mentors are eager to guide them. Participating in Outreachy also helps Rust expand its mentorship capacity and build a more inclusive contributor base, which strengthens the entire community.
How many interns will Rust mentor in the May 2026 cohort, and what are their projects?
Due to limited funding and mentoring resources, the Rust Project has selected four interns for the May 2026 Outreachy cohort. Three of the projects have been announced:
- Calling overloaded C++ functions from Rust – mentored by teor, Taylor Cramer, and Ethan Smith, with intern Ajay Singh. This project aims to experimentally support the invocation of overloaded C++ functions directly from Rust code, and will test the feature in a few representative scenarios.
- Code coverage of the Rust compiler at scale – mentored by Jack Huey, with intern Akintewe Oluwasola. The goal is to develop workflows to run and analyze code coverage for the entire compiler test suite and ecosystem crates detected by crater, ultimately building tools for continuous coverage analysis to detect inadequate testing.
- Fuzzing the a-mir-formality type system implementation – mentored by Niko Matsakis, Rémy Rakic, and tiif, with intern Tunde-Ajayi Olamiposi. This project focuses on implementing fuzzing for a-mir-formality, an in-progress model for Rust's type and trait system, to uncover edge cases and improve correctness.
What is the goal of the project to call overloaded C++ functions from Rust?
This experimental project, led by intern Ajay Singh under the guidance of mentors teor, Taylor Cramer, and Ethan Smith, aims to enable Rust code to invoke C++ functions that share the same name but differ in parameter types—a common pattern known as function overloading. Currently, Rust's FFI mechanisms only support calling C functions directly, and overloaded C++ functions require manual disambiguation or wrapper code. The project will design and implement a method, likely through a custom attribute or code generation, to let Rust users call overloaded C++ functions naturally. Initial testing will focus on a few representative use cases, such as graphics APIs or libraries with multiple overloads. Successful implementation would significantly simplify interoperability between Rust and existing C++ codebases, broadening Rust's appeal for systems programming where C++ legacy is prevalent.
What is the goal of the code coverage project for the Rust compiler?
Intern Akintewe Oluwasola, mentored by Jack Huey, will develop workflows to measure how thoroughly the Rust compiler is tested—both internally and across the ecosystem. The project aims to run code coverage analysis on the entire compiler test suite (comprising thousands of tests) and on popular ecosystem crates tracked by crater (a tool that tests Rust changes against many crates). By analyzing coverage at this scale, the team hopes to identify parts of the compiler that are insufficiently tested, whether in terms of code paths, error handling, or edge cases. The ultimate deliverable is a set of tools for performing continuous coverage analysis, so that as new compiler features are added, testing adequacy can be automatically evaluated. This will help maintain code quality and reduce the risk of regressions.
What is the goal of the fuzzing project for a-mir-formality?
Intern Tunde-Ajayi Olamiposi, with mentors Niko Matsakis, Rémy Rakic, and tiif, will work on fuzzing a-mir-formality—a formal model of Rust's type and trait system that is still under development. Fuzzing involves generating random or semi-random input to test a system for crashes, unexpected behavior, or non-conformance to specifications. For this project, the fuzzer will create various Rust programs and type-checking scenarios to exercise the formal model, uncovering inconsistencies or gaps between the model and actual compiler behavior. This is crucial because a-mir-formality is intended to serve as a rigorous foundation for future language evolution; ensuring it correctly captures Rust's semantics through fuzzing will help prevent subtle bugs and inform language design decisions. The project will also contribute to building a robust testing infrastructure for the model.