Python 3.15 Hits Feature Freeze with First Beta
With the first beta of the Python 3.15 release now available, the language has formally entered feature freeze—no new features will be accepted for this version from this point forward. This marks the transition from active innovation to stabilization, as the core team focuses on fixing bugs, polishing new capabilities, and ensuring compatibility before the planned final release in October. Among the headline additions are a stable application binary interface (ABI) for free-threaded CPython, explicit lazy imports to accelerate application startup, a new zero-overhead sampling profiler named Tachyon, and UTF-8 as the default text encoding. Together, these changes are designed to improve developer experience, observability, and runtime behavior without radically altering the language itself. For teams considering adoption, the beta status means APIs are largely set, making it a suitable time to begin testing against real projects.
JIT Compiler Improvements Promise Noticeable Python Performance Gains
Python 3.15 significantly advances the experimental just-in-time (JIT) compiler first introduced in Python 3.14. While the earlier iteration was not recommended for production and could even slow code down, the latest version delivers measurable Python performance gains in many scenarios. The core team now reports an average 8–9 percent improvement over the traditional CPython interpreter on x86-64 Linux systems and 12–13 percent on Apple silicon macOS, though specific workloads can still see up to 15 percent slower execution. These numbers may shift as optimization and stabilization continue during the beta period, but they signal that JIT compiler improvements are becoming a serious option for performance-conscious developers. Teams running CPU-bound tasks or large-scale services should begin profiling with the new JIT to identify hotspots and understand how the evolving implementation affects their particular code paths.
Free-Threaded CPython, Lazy Imports and Tachyon Reshape Developer Workflows
Beyond raw speed, Python 3.15 introduces features that can change how developers structure and observe applications. The stable ABI for free-threaded CPython builds builds on the earlier option to remove the global interpreter lock (GIL), making it easier for extension authors to ship binaries that work across multiple minor versions without constant recompilation. This should gradually reduce friction for widely used C extensions that want to embrace efficient concurrency on multi-core CPUs. Explicit lazy imports, enabled by a new keyword, allow modules to be loaded only when first accessed instead of at startup, delivering faster application initialization without resorting to obscure workarounds. Meanwhile, the Tachyon sampling profiler captures stack traces at very high sampling rates with virtually zero overhead, enabling developers to analyze performance issues—including in production environments—without the intrusive instrumentation often associated with traditional profilers.
Incremental Garbage Collector Pulled Back, Stability Takes Priority
Not every recent experiment has made the cut for Python 3.15. The incremental garbage collector, introduced in Python 3.14 to reduce pause times by reclaiming memory less frequently, has been removed after reports of memory leaks. It was reverted in Python 3.14.5, and the core team has indicated that any future attempt to reintroduce incremental GC—for example in a possible Python 3.16—will need to go through the full PEP process and more extensive evaluation. Its absence in Python 3.15 underscores the conservative stance of the feature freeze period: stability outweighs experimental gains at this stage of the release cycle. For developers, this means the upcoming version should feel more predictable, with fewer surprises in memory behavior. Teams that tested incremental GC will need to revisit any assumptions made around long-running processes and tune their applications using the traditional garbage collection model instead.
What Developers Should Do Before the Final Python 3.15 Release
With the Python feature freeze in effect, now is the ideal time for teams to evaluate Python 3.15 against their existing codebases. Developers should start by running automated test suites under the beta, paying special attention to performance-sensitive components and extensions that rely on CPython’s C API. Experimenting with the JIT compiler is particularly important: profile representative workloads, compare performance with and without JIT, and document any regressions or slow paths to report upstream. Extension authors can explore the new stable ABI for free-threaded builds to prepare for a future where the GIL is less central. It is also wise to test lazy imports and UTF-8-by-default behavior in staging environments, as these can subtly affect startup and text-handling logic. Early feedback during the beta phase helps ensure a smoother upgrade path when the final Python 3.15 release arrives.