Python 3.15

Original Article ↗ Hacker News Discussion ↗

Python 3.15 introduces performance gains and notable new features, including an upgraded experimental JIT, explicit lazy imports for faster startup, a new sampling profiler (“tachyon”), unpacking in comprehensions, and a built‑in `frozendict` type. Contributors highlight the new abi3t stable ABI for the free‑threaded build as a major step toward easier binary compatibility across interpreter variants, reducing packaging and CI complexity. Much of the debate centers on version support policies, with maintainers welcoming the chance to drop EOL interpreters while users on older systems worry about breakage and the growing need to manage separate Python runtimes outside what their OS bundles.

Release page and distribution quirks

  • Some users report broken or mis-anchored links on the 3.15 release page (e.g., Sentinel, lazy imports linking to bottom of page).
  • The xz source tarball is notably larger than 3.14; investigation points to ~10MB of animated GIFs in the docs (for the Tachyon profiler).
    • Some see this as unnecessary bloat and would prefer lightweight SVG-based docs.
    • Others argue critics should contribute improved assets instead.

Performance, JIT, and profiling

  • The experimental JIT’s reported 7–12% speedups (depending on platform) are welcomed as solid incremental gains.
  • The new Tachyon sampling profiler is highlighted as especially useful for profiling running processes in production.

Lazy imports and startup

  • PEP 810’s explicit lazy imports generate excitement, especially for large or startup-sensitive applications.
  • Some ask why it isn’t enabled globally; answers point to:
    • Import-time side effects (e.g., registries) and nondeterministic import order.
    • PEP 810 explicitly documents these tradeoffs.
  • A static analyzer (“lifeguard”) is mentioned that scans code to identify where lazy imports are safe to enable.

Version support, packaging, and OS Python

  • Maintainers welcome 3.15 mainly because 3.10 is now EOL, freeing them to rely on 3.11+ features.
  • Debate:
    • Maintainers argue indefinite support for old versions is unrealistic; users can stay on older package versions, and metadata ensures pip picks a compatible release.
    • Some users dislike the norm of “dropping” old Pythons when they’re still shipped by distros or vendors.
  • Enterprise/Linux distros often outlive upstream Python support, but ship newer interpreters in parallel streams.
  • macOS’s pinned/bundled Python (3.9 via Xcode) is seen as outdated and confusing; consensus is to avoid system Python and use managed environments (e.g., uv, virtualenvs).

Typing, AI, and performance

  • One commenter claims LLMs perform better on untyped Python and that annotations may be “noise” given most training data is untyped.
  • Others counter that:
    • Runtime performance doesn’t benefit from annotations today.
    • Types are still crucial for human clarity, correctness, and professional-grade code.

Free-threaded Python and abi3t

  • The new “abi3t” stable ABI for the free-threaded build is praised as a major ecosystem enabler.
    • Example: some key libraries already ship a single wheel usable by both GIL and free-threaded builds on 3.15+.
  • Maintainers note large CI reductions when using stable ABIs and anticipate easier future support across versions.
  • There are ongoing questions about which C APIs will graduate into the limited/abi3(t) surface.

Language features and PEPs

  • Several small but long-desired features get positive attention:
    • Unpacking in comprehensions (PEP 798).
    • Built-in frozendict (PEP 814).
    • UTF-8 as default encoding across platforms (PEP 686), especially beneficial on Windows and misconfigured containers.
  • Some users are surprised UTF-8 wasn’t already the universal default, reflecting subtle previous behavior (locale-dependent).

Language ecosystem and Rust debate

  • A side-thread speculates that only TypeScript/JavaScript, Rust, and Python will “survive,” with large-scale rewrites to Rust (including some real-world examples).
  • Others push back:
    • Point out entrenched ecosystems (C, C++, Java, C#, Swift, Kotlin, COBOL, embedded C) are unlikely to vanish.
    • Note that CPython’s core is not being rewritten in Rust; current efforts only explore allowing some Rust components.
  • Some argue fewer languages would be good; others prefer ongoing diversity and innovation, especially with AI tooling.