Python's development team is taking a more flexible approach to bringing Rust into CPython, the reference implementation of the widely used programming language. Rather than immediately making Rust a required part of Python's build process, developers are exploring an incremental integration strategy that would allow selected components to use Rust while preserving existing C implementations.
The proposal reflects an important architectural decision for Python's future. Rust offers memory-safety features that could help prevent certain classes of programming errors, but CPython must also maintain compatibility with a broad range of operating systems, hardware architectures and development environments. The challenge is introducing those benefits without making Python harder to build, distribute or maintain.
Why CPython Is Considering Rust
CPython has historically relied heavily on C for its interpreter and core implementation. Although C provides low-level control and extensive platform support, manual memory management can introduce vulnerabilities such as use-after-free errors, buffer overflows and other memory-safety problems.
Rust approaches memory management differently through its ownership and borrowing systems, which help prevent many memory-related errors at compile time. The Rust for CPython initiative aims to explore whether these protections can make selected parts of the interpreter safer and easier to maintain.
At the 2026 Python Language Summit, project representatives discussed the potential benefits of adopting Rust and the technical challenges that must be resolved. The initiative has attracted a community of approximately 60 developers, including contributors from the Python and Rust ecosystems.
Python Is Moving Away From a Mandatory Rust Requirement
One of the most important changes is the decision to pursue optional integration rather than immediately requiring Rust to build CPython. This approach addresses concerns about platform compatibility, development complexity and the additional requirements that a mandatory Rust toolchain could introduce for Python distributors.
Instead of attempting to rewrite large sections of the interpreter, the proposal focuses on introducing Rust gradually. Existing C implementations would remain available as fallback options, allowing developers and distributors to evaluate the new approach without immediately abandoning established build environments.
This is particularly important because CPython supports numerous operating systems and hardware architectures. Any new dependency must work across that ecosystem, including platforms where compiler support and development resources may be more limited.
Why the zlib Module Is the First Target
The project has identified the zlib compression module as a potential first component for an optional Rust implementation. The proposed approach would use zlib-rs, a Rust-based compression library that has already been used by projects including Firefox, uv and Cargo.
Compression is an important part of Python's software ecosystem, including package distribution and installation workflows. If the proposed implementation is accepted and performs as expected, Python developers could eventually benefit from a Rust-powered compression backend without needing to change their applications.
However, this remains a proposed development direction rather than a completed feature available in a stable Python release. The implementation will need testing across supported platforms, compatibility checks and agreement on the project's engineering requirements.
What the Proposed Python Roadmap Looks Like
The roadmap discussed by the project places an important milestone in late 2026, when a Python Enhancement Proposal is expected to define the success criteria for Rust integration. The proposal would establish how the project should be evaluated before broader adoption is considered.
Python 3.16, currently targeted for October 2027, is proposed as the first release that could include an optional Rust implementation of zlib. Python 3.17 could bring Rust into additional components, depending on testing results and platform compatibility. Making Rust a required dependency is not expected before a much later stage, with Python 3.18 in 2029 discussed as the earliest possible point under the proposed timeline.
These dates represent a development proposal, not guaranteed release commitments. The final direction will depend on technical progress, community feedback and decisions by Python's core development leadership.
What This Means for Python Developers
For application developers, the proposed changes are not expected to require an immediate rewrite of existing Python projects. The focus is on improving the implementation beneath the language rather than changing everyday Python syntax or application programming interfaces.
For contributors and maintainers, however, the transition could introduce new opportunities to work with Rust alongside C. It may also require improvements to build systems, testing infrastructure, debugging tools and cross-language interfaces to ensure that both languages can operate reliably within the same interpreter.
A Gradual Strategy for Python's Future
Python's evolving Rust strategy highlights a broader challenge facing mature software projects: adopting newer technologies without disrupting the compatibility and stability that existing users depend on. Rust could provide meaningful memory-safety advantages, but successful integration will require careful engineering and long-term maintenance.
Rather than pursuing a complete rewrite, the CPython project is exploring a gradual path that keeps existing systems working while allowing selected components to benefit from Rust. If the approach succeeds, it could influence how Python develops its interpreter and core libraries over the next several release cycles.
