Python 3.15 Reaches Beta and Feature Freeze
Python 3.15 has hit its first beta release, which also marks the feature freeze point for this development cycle. From now until the scheduled final release on October 1, the core team will focus on stabilization, bug fixing, and performance tuning rather than new features. This cycle follows the project’s familiar annual cadence, where one major feature release lands in October and no new capabilities are added after the first beta. For developers, this beta is the first realistic opportunity to evaluate Python 3.15 in real-world projects, validate compatibility of dependencies, and begin planning upgrade timelines. Because the ABI and language behavior are now effectively locked, teams can test against this beta with confidence that breaking changes are unlikely, while still providing feedback on any regressions or edge cases uncovered during integration and performance testing.
A Faster, More Mature Python 3.15 JIT Compiler
The experimental JIT compiler introduced in Python 3.14 has received substantial tuning in Python 3.15, shifting from curiosity to a more compelling performance option. According to the core team, the latest implementation delivers a mean performance improvement of around 8–9 percent over the traditional CPython interpreter on x86-64 Linux, and 12–13 percent on Apple silicon macOS. These gains are still experimental and may change before the final release, and some workloads can run up to 15 percent slower, so careful benchmarking remains essential. Still, the trend is clear: the Python 3.15 JIT compiler is maturing into a practical tool for performance-sensitive applications. Combined with ongoing efforts like free-threaded CPython and a stable ABI for those builds, the JIT is becoming one more lever developers can pull in pursuit of Python performance improvements without rewriting hot paths in C or another language.
Garbage Collector Rollback: Why the Incremental GC Is Still Missing
While the JIT moves forward, the garbage collector story is more cautious. The incremental garbage collector first shipped in Python 3.14 promised better performance by reclaiming memory less frequently, reducing pause times in some workloads. However, reports of memory leaks led to its reversion in Python 3.14.5. As a result, Python 3.15 ships without this incremental GC, reverting to the more conservative, established behavior. The core team has indicated that if incremental GC is to return in a future release such as 3.16, it will do so through the full Python Enhancement Proposal process, with significantly more scrutiny and evaluation. For developers, this means there is no new GC mode to tune in 3.15 beta. Instead, memory-management behavior should feel familiar, reducing risk but also delaying potential gains in latency and throughput that an effective incremental collector could someday provide.
What Python 3.15’s Changes Mean for Developers and Performance
Beyond the JIT and GC, Python 3.15 delivers several features that reshape performance tuning and everyday development workflows. A stable ABI for free-threaded CPython reduces the burden on extension maintainers, who no longer need to rebuild binaries for every minor release when targeting that subset of the API. Lazy imports, enabled via a new keyword, let developers defer module loading until first use, improving startup time without resorting to awkward architectural workarounds. The Tachyon sampling profiler offers virtually zero-overhead profiling at very high sampling rates, making performance diagnostics more viable in production scenarios. Finally, UTF-8 becomes the default text encoding, aligning behavior with modern expectations while still encouraging explicit encodings for compatibility. Taken together with the maturing Python 3.15 JIT compiler, these changes invite teams to revisit performance assumptions, refine startup behavior, and build more maintainable high-performance Python applications.