Rust Foundation Interop Initiative Update: From Research to Implementation

As Rust adoption expands around the world and across many different domains, the challenge is not simply helping teams write new software in Rust. It is helping them introduce Rust into the systems they already have: large, long-lived, mixed-language environments where languages like C and C++ remain deeply embedded. For many organizations, the path to Rust runs directly through these existing codebases, making language interoperability one of the most important infrastructure challenges we face. 

To help address this need, the Rust Foundation launched the Interop Initiative in 2024. The initiative focuses on improving how Rust works alongside other languages (particularly C++) by identifying ecosystem challenges, coordinating stakeholders, and supporting technical work that reduces friction in mixed-language systems.

This update provides a status overview of the work conducted so far and outlines the next phase of the initiative.

Ecosystem Support

The Rust Foundation would like to thank Google for funding the initial phase of the Interop Initiative. Their support enabled the early research and coordination necessary to begin exploring Rust–C++ interoperability challenges at ecosystem scale.

We are also grateful to the many members of the Rust Project, contributors from adjacent language communities, and various partners who participated in early discussions and shared insights from real-world systems. Interoperability challenges span multiple communities, and the input gathered during this phase has been critical in shaping the initiative’s direction.

Groundwork: 2024-Q1 2026

The initial phase of the Interop Initiative focused on understanding and defining the problem space.

Interoperability between programming languages is a complex topic that spans many layers of the software stack. ABI boundaries, language semantics, existing library APIs, tooling, build systems, and long-term maintenance considerations all play a role in how languages interact within large codebases.

Since its inception, the initiative has focused on foundational research and stakeholder engagement to better understand these challenges. This work included:

• Conducting ecosystem research into mixed-language development environments.
• Engaging stakeholders across the Rust and C++ communities.
• Identifying areas where current interoperability approaches create friction or risk.
• Developing a formal problem statement describing these challenges.

This effort resulted in the publication of a Rust–C++ interoperability problem statement, which outlines key challenges and opportunities in the current ecosystem. The problem statement also informed the creation of a Rust Project Goal focused on improving cross-language interoperability. 

Because interoperability inherently touches many parts of the software ecosystem, meaningful progress requires coordination between language communities, tooling maintainers, and organizations operating large systems. Building this early, shared understanding of the problem space was, therefore, a necessary first step.

Clarifying the Central Challenges

The research conducted during this phase highlighted several areas where improvements could significantly reduce friction for developers working across Rust and C++.

These challenges include improving existing tooling and infrastructure to support mixed-language development, identifying opportunities for better conventions and coordination between ecosystems, exploring longer-term improvements that may require changes within Rust itself, and even examining what potential changes could be made to C++ to make interop more ergonomic, efficient and effective.

The problem statement and Rust Project Goal provide a framework for addressing these challenges collaboratively. They establish clearer priorities and help guide future technical efforts.

Most importantly, they reflect an important reality of modern systems programming: Rust and C++ will continue to coexist in many environments. Improving interoperability between them helps organizations adopt Rust incrementally while maintaining performance, reliability, and maintainability.

Focusing On the Long Game

After completing the problem statement, we made a deliberate bet: that a safer C++ would provide the best long-term foundation for high-performance, ergonomic C++/Rust Interop. 

Our reasoning was straightforward: If the interop boundary itself remains a safety hazard, every integration inherits that risk. Instead, we wanted to help create a context within C++ where new semantics and defaults could evolve – ones suited to Rust interoperability. In the process, this could also improve the interoperability between all memory-safe languages interacting with C++. 

Innovation in this space is long overdue. At the same time, the pressure on C++ to address memory safety presented an unprecedented opportunity. If approached collaboratively, our Rust/C++ Interop Initiative could help catalyze progress that benefits both communities, and the vast ecosystem of technology built on C++. 

Throughout 2025, we steadily increased investment in engaging with the C++ community, particularly the WG21 in ISO, the committee responsible for the standardization of C++. Through sustained relationship-building and the development of a memory-safe C++ proposal, we achieved better-than-expected early results. Most notably, there was a strong initial consensus around a clearly stated goal: adding memory safety to C++. 

However, standardizing memory safety in C++ is an ambitious project which will take years. Memory-safety is not just one specific feature addition, but a paradigm shift that has touchpoints throughout the entire language. Progress within the ISO process requires consensus among hundreds of members representing dozens of national bodies – difficult by design. When changes impact a language as globally pervasive as C++, caution and deliberation are essential. Even in the most optimistic scenario – where memory-safety was ultimately approved by the WG21 and implementation began in 2026 – C++’s standard 3-year release cycle means the earliest this could hit production would be 2029. Realistically, given the scope of such an addition, it would very likely take multiple release cycles to achieve this goal.

Mara Bos, an established leader in the Rust Project, and I went to the most recent WG21 meeting in Croydon, UK. I attended to gauge how memory-safe C++ was being received by the committee as well to find areas of common interest as it pertains to interop. Mara attended as both an advisor to the Rust Foundation on how we may potentially work with the WG21 on interop as well as to build bridges between the Rust and C++ communities. Mara, who was a past WG21 member and has had an impact in C++, was able to help us create many connections, a testament to the kind of cross-community credibility that makes real collaboration possible. Our general takeaway from attending this meeting was that near-term progress is more likely to come through targeted collaboration on specific interop improvements than through broad memory-safety proposals, whether via direct WG21 paper submissions or a potential Rust/C++ study group.

In the end, developers are in need of better Rust/C++ interop now. The growing number of tools that are being developed in this space reflect just how large the current gaps are. For that reason, while we will continue to monitor potential memory-safe C++ work, we are shifting our primary focus to the near-term. Our immediate priority is making substantial progress on our problem space mapping goal, organizing the challenges into clear problem statements so that both communities can more effectively propose and evaluate solutions.

The Next Phase

Understanding that better Rust/C++ interop solutions are needed today, and with our foundational work in place, the Rust Foundation is now moving the Interop Initiative into its next phase.

This phase will focus on translating the more high-level research and problem framing into upcoming concrete technical work.

To support this effort, the Foundation has engaged Teor as a contractor to help advance the initiative in collaboration with the Rust Project and ecosystem stakeholders. This work includes making concrete progress on the Rust/C++ Interop Problem Space Mapping goal, facilitating discussions across communities, and helping coordinate technical efforts.

 “After encountering interop issues integrating Rust libraries into projects like Tor and Zcash, I’m happy to be working to solve them. We’re still in the early stages, discovering and documenting some common problems and interop use cases. I’m looking forward to experimenting with some interop improvements – watch this space!” – Teor

We intend to continue working closely with Rust Project teams, contributors from the C++ ecosystem, and industry stakeholders to identify and pursue practical solutions in the next phase.

From Research to Implementation

The next phase of the Interop Initiative will focus on turning the research and problem statements into tangible engineering outcomes.

Key activities will include:

• Partnering with ecosystem stakeholders to refine and prioritize specific interoperability challenges.
• Establishing focused working groups or technical initiatives around defined problem areas.
• Coordinating with relevant Rust Project teams.
• Engaging with the C++ community and standards bodies where shared challenges exist.
• Supporting the development of tools, infrastructure improvements, and documentation that make mixed-language development easier and safer.

The goal of this phase is to deliver practical improvements that help Rust integrate more smoothly into existing systems while preserving Rust’s safety and reliability guarantees.

Sustaining and Supporting This Important Work

Organizations that rely on large, mixed-language systems have a strong stake in this work. Improving interoperability between Rust and other systems languages helps make incremental adoption possible while preserving safety, reliability, and performance.

The Rust Foundation welcomes collaboration with ecosystem partners and industry stakeholders interested in supporting and participating in this effort. 

Organizations interested in contributing engineering support, funding, or expertise are encouraged to email the Rust Foundation at interop@rustfoundation.org to help advance this next phase of the Interop Initiative. 

Looking Ahead

The Rust Foundation is committed to supporting the long-term health and sustainability of the Rust ecosystem.

The Interop Initiative is now entering a more focused, execution-driven phase built on the research and engagement conducted over the past several years. By continuing to collaborate across communities, the Foundation aims to address key interoperability challenges and deliver improvements that benefit developers working in mixed-language environments.

If you’re interested in the development of this work, please follow the related Zulip stream for updates. You can also find monthly updates in the Interop Project Goal GitHub issue here. 

We look forward to working with contributors across the Rust ecosystem and the broader systems programming community as this work moves forward.