Python

Track CPython development and the evolution of the world's most popular programming language.

About this developer podcast

Python turns GitHub activity into short audio updates.

Episodes cover commits, pull requests, issues, and release work.

Use this page to listen, subscribe, and find related developer podcasts.

This show page is the public hub for the podcast. It has one stable listen URL.

Use it to find RSS feeds, recent episodes, related shows, and older episode links.

If the project is quiet, new episodes may pause until there is useful activity to summarize.

Recent episodes from Python

  1. Free-Threading Fixes and GC Speedups

    Core runtime work dominated the cycle, with fixes for free-threading pauses, fork deadlocks and data races alongside memory-safety hardening for text and bytes handling. A stack of five open proposals aims to cut garbage collector…

  2. Free-Threading Races, Core Speedups, and Stdlib Hardening

    Activity centers on reliability under free-threading and interpreter shutdown, plus faster hot paths for class creation, I-O, and asyncio. Stdlib email, packaging, and build cleanup round out the day.

  3. Free-Threading Crash Fixes and Cleanup Guarantees

    The dominant pattern is memory-safety and concurrency hardening for free-threaded Python, with multiple use-after-free, race, and crash fixes. Paired archive fixes guarantee files close on finalization, alongside build correctness fixes…

  4. Free-Threading Hardening and iOS Builds

    Free-threading stability dominates this cycle, with fixes for stop-the-world starvation and weak-reference races, alongside new iOS build options and standard library reliability fixes. Backports to 3.14 and 3.15 account for much of the…

  5. Deterministic Pyc Files and Threading Hardening

    Marshal and compiler fixes make pyc output reproducible across processes and builds. Free-threading crash fixes and a lazy multiprocessing default improve stability and startup performance.

  6. Reproducible Marshal Output and Runtime Speedups

    The dominant pattern is a push for deterministic marshal and compiler output to make dot-pyc files reproducible, alongside GC, allocator, and interpreter performance work. Backports fix async networking hangs, threading races, and mobile…

  7. Weekly Recap - Thread Safety, GC Efficiency and Platform Polish

    CPython landed thread-safety fixes for error reporting, bytes joining and syslog alongside garbage collector optimizations. The week also brought marshal correctness fixes and steady iOS, WASI and IDLE polish across 3.14 and 3.15 branches.

  8. Garbage Collector Speedups and Thread-Safety Fixes

    The garbage collector dominated activity with one merged optimization and four follow-ups to cut collection pauses, while separate fixes hardened the error-string and syslog modules for free-threading and subinterpreters.

  9. IDLE Reliability Push and WASM Trampoline
  10. Crash Hardening and Release Readiness
  11. Runtime Hardening and Faster I/O
  12. Free-Threading Safety and C API Hardening
  13. 3.15 Freeze Revert and Profiler Hardening
  14. Remote Inspection Hardening and Memory Safety Push
  15. Weekly Recap - Lazy Imports Harden, Safety and Observability Tighten
  16. Free-Threading Stability and Bytes Safety
  17. Lazy Imports Harden, Hot Paths Speed Up
  18. Lazy Import Overhaul and Bytes Hardening
  19. JIT Guard Fixes and Security Backports
  20. Concurrency Races and String Hardening
  21. C Safety Fixes and Version APIs
  22. Clinic Cleanup Wave and Free-Threading Fixes
  23. Weekly Recap - Stabilization, C API Cleanup and Backports
  24. Lazy Import Fix and IDLE Hardening
  25. Free-Threading Fairness and Tokenizer Cleanup
  26. Runtime Hardening and Profiler Reliability
  27. Security Backports and IDLE Reliability Push
  28. IDLE Stability and Free-Threading Safety
  29. C API Lockdown and Free-Threading Gains
  30. Core Speedups and Interactive Tool Fixes
  31. Weekly Recap - Core Speedups, Text Handling and Release Stabilization
  32. F-String Slowdown Fix and Runtime Hardening
  33. Cleanup, Correctness, and a Trickle of Backports
  34. Hardening Memory Safety at the Core
  35. IDLE Gets a Major Reliability Sweep
  36. Hardening the Core Against Silent Corruption
  37. Parser Speed and Memory Safety Sweep
  38. XML Cleanup, Parser Speedups, and a Docs Split
  39. Weekly Recap - Memory Safety, Bytes Internals, and Doc Restructuring
  40. Hardening the Bytes Core and Trimming the Parser
  41. Hardening the Bytes Writer, Cleaning Up Async Task Tracking
  42. Free-Threading Bugs Take Center Stage
  43. Buffer Safety Sweep in Bytes and Strings
  44. Correctness Cleanup Across the Board
  45. Buffer Bugs and the Long Tail of Correctness Fixes
  46. Hardening the Hash Modules and Chasing a Tokenizer Rewrite
  47. Weekly Recap - Documentation Cleanup and Compiler Fixes
  48. Asyncio Cleanup and Free-Threading Safety
  49. Error Handling Gets Serious
  50. Backport Wave and Precision Fixes
  51. The Great Documentation Cleanup
  52. XML Cleanup and Memory Tracing Gains
  53. XML Overhaul and a Security Patch Sweep
  54. XML Cleanup and Correctness Fixes Take Center Stage
  55. Weekly Recap - Compiler Cleanup and Windows Path Fixes
  56. Windows Path Fixes and DOM Standards Cleanup
  57. Compiler Cleanup and Tokenizer Consolidation
  58. Tokenizer Overhaul and Compiler Cleanup Wave
  59. Correctness Fixes Across Error Handling and Startup
  60. Cleanup Cycle for CPython Internals
  61. Curses Cleanup and Correctness Fixes Across the Board
  62. Argument Clinic Consolidation and Thread-Safety Fixes
  63. Weekly Recap - Crash Fixes and Cleanup Across the C Layer
  64. Data Corruption Fixes and a Cleanup Sweep in Curses and Zlib
  65. Crash Fixes Sweep the Backports
  66. The Great Attribute Deletion Bug Hunt
  67. C Attribute Setters Get a Cleanup Pass
  68. Free-Threading Hardens, Backports Sweep the Board
  69. Memory Safety Sweep in CPython Internals
  70. Marshal Module's Bad Week
  71. Weekly Recap - Data Integrity and Backport Discipline
  72. Curses Cleanup and a Wave of Correctness Fixes
  73. Free-Threading Race Conditions Take Center Stage
  74. Data Corruption Fixes and the Great Backport Sweep
  75. System Calls, Copy Replace, and a Reference Leak Fix
  76. Expat Patch Sweeps the Branches, Old Bugs Finally Close
  77. Security Backports and a Cleaner C API
  78. Backports, Security Fixes, and Long-Standing Bug Cleanup
  79. Weekly Recap - Argument Clinic Overhaul & Cross-Platform Reliability
  80. Windows Path and Encoding Cleanup Marathon
  81. Structseq Cleanup and Data-Race Hardening
  82. Three Ways to Solve One Keyword Argument Problem
  83. Argument Clinic Gets a Deep Overhaul
  84. Argument Clinic Gets a Major Overhaul
  85. Security Backports and the Algorithmic Complexity Sweep
  86. CSV Sniffer Gets Untangled From Exponential Time
  87. Weekly Recap - Correctness Fixes and Release Prep
  88. Decimal, Copy Semantics, and a Logging Race Fix
  89. Crash Fixes Across Async and Memory Internals
  90. Curses Cleanup and Correctness Fixes Dominate the Day
  91. Hardening the Corners Before 3.15
  92. Thread Safety and the Great Regex Slowdown Cleanup
  93. Curses Crashes and a Careful Revert
  94. Curses, Concurrency, and a Reflog Revert
  95. Weekly Recap - Memory Safety and Backport Discipline
  96. Locale Encoding Bugs Take Center Stage
  97. Memory Safety Sweep Across the Interpreter
  98. A Day of Memory Safety Hunting
  99. Concurrency Bugs and Logging Hangs Get Cleaned Up
  100. Data Races, Backports, and BSD Portability

Episode archive for Python

  1. Chasing Down the Long Tail of Platforms
  2. Asyncio Subprocess Reliability, Cross-Platform Cleanup
  3. Weekly Recap - Platform Portability and Reliability Cleanup
  4. Curses Portability and Ctypes Decorator Cleanup
  5. Backports, Free-Threading Fixes, and a Docs Cleanup Wave
  6. Cleanup Sprint Hits Old Bugs and Security Gaps
  7. Hardening the Edges of the Standard Library
  8. Memory Safety Sweep Across the Interpreter
  9. Error Handling Cleanup Across the Standard Library
  10. Compression Modules Get a Cleanup Pass
  11. Weekly Recap - Process Cleanup, Tkinter Overhaul, and Backport Discipline
  12. Parser Speed and Buffer Safety
  13. Tkinter's Big Cleanup Push
  14. Cleaning Up How the Interpreter Starts and Talks to the World
  15. Concurrency Bugs and Free-Threading Cleanup
  16. Free-Threading Race Conditions Take Center Stage
  17. Correctness Fixes and a New Tkinter Accessibility Push
  18. The IMAP Library Gets a Deep Cleanup
  19. Weekly Recap - IMAP Overhaul & Parser Hardening
  20. Old Bugs, Long Overdue Fixes
  21. Free-Threading Races and a Reliability Sweep
  22. Concurrency Bugs Get Squashed Across Branches
  23. Security Fixes and Code Cleanup
  24. Weekly Recap - Memory Safety and Stability Fixes
  25. Memory Safety and Performance Fixes
  26. Memory Safety and Process Pool Fixes
  27. Memory Safety and Performance Optimizations
  28. Memory Safety and Performance Hardening
  29. Memory Management and Documentation Fixes
  30. Memory Safety and Crash Prevention Fixes
  31. Security Fixes and Documentation Cleanup
  32. Weekly Recap - Performance & Developer Experience
  33. Performance Optimizations and Security Fixes
  34. Math Functions and Memory Management
  35. Performance Optimizations and Free-Threading Stability
  36. Performance Focus and Developer Experience
  37. Performance Optimizations and Documentation Cleanup
  38. Security Fixes and JIT Optimization
  39. Cleanup and Cross-Platform Fixes
  40. Weekly Recap - Documentation Cleanup & Maintenance
  41. Performance Fixes and Security Updates
  42. Documentation and Maintenance Updates
  43. XML Parser Enhancement and Cygwin Compatibility
  44. Documentation Cleanup and Platform Fixes
  45. Security Fixes and Documentation Cleanup
  46. Memory Fixes and Performance Improvements
  47. Weekly Recap - JIT Optimization & Performance Focus
  48. Pickle Threading Fixes and Memory Monitoring
  49. Library Bug Fixes and Documentation Updates
  50. Core Fixes and Performance Improvements
  51. Security Fixes and Import System Updates
  52. Directory Permissions and Thread Safety Fixes
  53. Performance Optimizations and Security Fixes
  54. Security Fix and OpenSSL Updates
  55. Weekly Recap - Free-Threading Stability & Platform Compatibility
  56. Cygwin Compatibility and Security Updates
  57. Security Updates and Documentation Improvements
  58. Security Patches and Site Module Fix
  59. Library Cleanup and Performance Improvements
  60. Threading Safety and Email Parser Fixes
  61. Security Fixes and Site Module Updates
  62. Profiling Fixes and AsyncIO Improvements
  63. Security Fixes and Performance Optimizations
  64. Version 3.16 Release Preparation
  65. Frame Pointer Fixes and PEP 788 Implementation
  66. JIT Gets Supercharged & Developer Experience Wins
  67. JIT Performance and Debugging Enhancements
  68. Developer Experience Improvements
  69. Weekly Recap - Major Features and Core Improvements
  70. Core Improvements and JIT Debugging
  71. Frame Pointers and Email Handling Updates
  72. Weekly Recap - JIT Improvements & Developer Experience
  73. Developer Tools Get Color Support
  74. AsyncIO TaskGroup Enhancement and JIT Optimization
  75. JIT Infrastructure and Language Enhancements
  76. Monitoring Events and Security Updates
  77. Weekly Recap - JIT Infrastructure and Documentation Modernization
  78. Weekly Recap - Performance & Tooling Improvements
  79. Weekly Recap - REPL Enhancements & Infrastructure Updates
  80. Base64 Gets Better and Security Tightens Up
  81. JIT Compiler Gets Major Performance Boost
  82. Code Cleanup and Security Focus
  83. Spring Cleaning & iOS Evolution
  84. Base64 Gets a Major Upgrade
  85. Performance Insights and Platform Polish
  86. Security Fixes and Developer Experience Polish
  87. Error Handling Evolution and Quality of Life Wins
  88. JIT Compiler Gets Frame Pointer Safety & Performance Wins
  89. Complex Numbers Get First-Class Treatment
  90. JIT Optimization Surge and Testing Infrastructure Wins
  91. JIT Gets Smarter and Core Gets Cleaner
  92. Emscripten Takes Center Stage
  93. Base64 Gets a Speed Boost
  94. Documentation Cleanup and Performance Tweaks
  95. Performance & Safety Spring Cleaning
  96. Under the Hood Optimizations and Bug Squashing
  97. Core Stability & Performance Sprint
  98. Security & Performance Power-Up
  99. JIT Optimizations and AsyncIO Fixes
  100. Audio Adventures and Threading Safety
  101. Windows REPL Fix and Performance Wins
  102. Spring Cleaning and Performance Gains
  103. Thread Safety Sprint & Infrastructure Wins
  104. Spring Cleaning and Memory Management Magic
  105. The Great Memory Cleanup Day
  106. Crash Guards and Polish Pass
  107. Security & Performance Polish
  108. The Frozendict Revolution
  109. Security Fixes and Memory Magic
  110. Security Fixes and Memory Management Wins
  111. Spring Cleaning and Bug Squashing Bonanza
  112. Threading Fixes and Build Optimizations
  113. SIMD Speed Boost and JIT Improvements
  114. Documentation Revolution & frozendict Optimizations
  115. Regular Expressions Get Clearer and Core Gets Stronger
  116. Unicode Fixes and Threading Safety Updates
  117. Threading Race Conditions and Developer Experience Wins
  118. Small Fixes, Big Impact
  119. Unpacking Possibilities and JIT Optimizations
  120. Memory and Performance Powerhouse
  121. Subprocess Gets a Speed Boost
  122. Cleaning Up Our Act - Modern Python Gets a Language Makeover
  123. Better Error Handling and Quality of Life Improvements

More public developer podcasts

Browse other public Podlog show hubs with crawler-readable RSS and episode links.

  1. Next.js Daily 264 episodes
  2. Pi Mono 144 episodes
  3. OpenClaw 221 episodes
  4. RuView 175 episodes
  5. Godot Daily 209 episodes
  6. Agora Next Updates 280 episodes
  7. Rails Daily 264 episodes
  8. Home Assistant Daily 269 episodes
  9. Linux Kernel Daily 242 episodes
  10. Eleviewer Daily 2 episodes
  11. React Daily 160 episodes
  12. Jabref Daily 110 episodes
  13. BlocksBeyondTheStars Daily 89 episodes
  14. Jabref Daily 111 episodes
  15. Next Js Daily 99 episodes
  16. Headroom Daily 108 episodes
  17. Agent Of Empires Daily 99 episodes
  18. Buzz Transcription 106 episodes
  19. Frigate NVR Updates 247 episodes
  20. Linux Kernel 235 episodes
  21. Homebrew 259 episodes
  22. TypeScript 148 episodes
  23. Ruby on Rails 252 episodes
  24. Redis 227 episodes
  25. Next.js 261 episodes
  26. Vue.js 199 episodes
  27. Rust 232 episodes
  28. Ruby Core Updates 255 episodes
  29. Go 245 episodes
  30. VS Code 263 episodes
  31. TailwindCSS 155 episodes
  32. Node.js 257 episodes
  33. Django 249 episodes
  34. React Native 206 episodes
  35. PostgreSQL 248 episodes
  36. Kubernetes 258 episodes
  37. LangChain 243 episodes
  38. Ollama 247 episodes
  39. PyTorch 262 episodes
  40. Openharness Daily 71 episodes
  41. Maestro Daily 98 episodes
  42. Videorc Daily 91 episodes
  43. Navidrome Daily 119 episodes
  44. Shannon 107 episodes
  45. iCloud Photos Downloader 37 episodes
  46. NativeScript iOS Daily 46 episodes
  47. AtomVM Daily 21 episodes
  48. Rimworld ChickenBatteryCage Daily 1 episode
  49. The Algorithm Daily 20 episodes
  50. Agora Next Daily 16 episodes
  51. Onlook Design Updates 34 episodes
  52. Energy Inc Ace Mate Learning Daily 2 episodes
  53. tiny-gpu Daily 20 episodes
  54. OpenAI Skills 52 episodes
  55. Crush Daily 1 episode
  56. ControlNet Daily 0 episodes
  57. FinceptTerminal Daily 0 episodes