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. 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…

  2. 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.

  3. 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.

  4. IDLE Reliability Push and WASM Trampoline

    A wave of IDLE stability backports for Python 3.15 dominates the cycle, alongside deeper C API test coverage and a WebAssembly call fix. The pattern is reliability: fewer crashes and hangs in everyday tools and threading edge cases.

  5. Crash Hardening and Release Readiness

    The dominant pattern is interpreter stability, with fixes for free-threaded bytes join races, shutdown segfaults, and stack overflows. Long-tail email parsing correctness and 3.15 release prep round out the activity.

  6. Runtime Hardening and Faster I/O

    CPython merged memory-safety fixes for text I/O and concurrency hazards, strict HTTP framing validation, and lazy-import correction, plus faster buffered reads and list tuning. The pattern is safer core runtime behavior with cheaper…

  7. Free-Threading Safety and C API Hardening

    Free-threaded reliability dominates this cycle, with fixes for crashes, contention, and slowdowns alongside C API and build hardening. Extension authors and high-thread services see the most impact.

  8. 3.15 Freeze Revert and Profiler Hardening

    Maintainers reverted 14 backports that slipped in during the 3.15.0 freeze to keep the final clean for re-consideration in 3.15.1. Main-branch work focused on sampling-profiler reliability and smaller, faster, safer C internals.

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

Episode archive for Python

  1. Cleanup Sprint Hits Old Bugs and Security Gaps
  2. Hardening the Edges of the Standard Library
  3. Memory Safety Sweep Across the Interpreter
  4. Error Handling Cleanup Across the Standard Library
  5. Compression Modules Get a Cleanup Pass
  6. Weekly Recap - Process Cleanup, Tkinter Overhaul, and Backport Discipline
  7. Parser Speed and Buffer Safety
  8. Tkinter's Big Cleanup Push
  9. Cleaning Up How the Interpreter Starts and Talks to the World
  10. Concurrency Bugs and Free-Threading Cleanup
  11. Free-Threading Race Conditions Take Center Stage
  12. Correctness Fixes and a New Tkinter Accessibility Push
  13. The IMAP Library Gets a Deep Cleanup
  14. Weekly Recap - IMAP Overhaul & Parser Hardening
  15. Old Bugs, Long Overdue Fixes
  16. Free-Threading Races and a Reliability Sweep
  17. Concurrency Bugs Get Squashed Across Branches
  18. Security Fixes and Code Cleanup
  19. Weekly Recap - Memory Safety and Stability Fixes
  20. Memory Safety and Performance Fixes
  21. Memory Safety and Process Pool Fixes
  22. Memory Safety and Performance Optimizations
  23. Memory Safety and Performance Hardening
  24. Memory Management and Documentation Fixes
  25. Memory Safety and Crash Prevention Fixes
  26. Security Fixes and Documentation Cleanup
  27. Weekly Recap - Performance & Developer Experience
  28. Performance Optimizations and Security Fixes
  29. Math Functions and Memory Management
  30. Performance Optimizations and Free-Threading Stability
  31. Performance Focus and Developer Experience
  32. Performance Optimizations and Documentation Cleanup
  33. Security Fixes and JIT Optimization
  34. Cleanup and Cross-Platform Fixes
  35. Weekly Recap - Documentation Cleanup & Maintenance
  36. Performance Fixes and Security Updates
  37. Documentation and Maintenance Updates
  38. XML Parser Enhancement and Cygwin Compatibility
  39. Documentation Cleanup and Platform Fixes
  40. Security Fixes and Documentation Cleanup
  41. Memory Fixes and Performance Improvements
  42. Weekly Recap - JIT Optimization & Performance Focus
  43. Pickle Threading Fixes and Memory Monitoring
  44. Library Bug Fixes and Documentation Updates
  45. Core Fixes and Performance Improvements
  46. Security Fixes and Import System Updates
  47. Directory Permissions and Thread Safety Fixes
  48. Performance Optimizations and Security Fixes
  49. Security Fix and OpenSSL Updates
  50. Weekly Recap - Free-Threading Stability & Platform Compatibility
  51. Cygwin Compatibility and Security Updates
  52. Security Updates and Documentation Improvements
  53. Security Patches and Site Module Fix
  54. Library Cleanup and Performance Improvements
  55. Threading Safety and Email Parser Fixes
  56. Security Fixes and Site Module Updates
  57. Profiling Fixes and AsyncIO Improvements
  58. Security Fixes and Performance Optimizations
  59. Version 3.16 Release Preparation
  60. Frame Pointer Fixes and PEP 788 Implementation
  61. JIT Gets Supercharged & Developer Experience Wins
  62. JIT Performance and Debugging Enhancements
  63. Developer Experience Improvements
  64. Weekly Recap - Major Features and Core Improvements
  65. Core Improvements and JIT Debugging
  66. Frame Pointers and Email Handling Updates
  67. Weekly Recap - JIT Improvements & Developer Experience
  68. Developer Tools Get Color Support
  69. AsyncIO TaskGroup Enhancement and JIT Optimization
  70. JIT Infrastructure and Language Enhancements
  71. Monitoring Events and Security Updates
  72. Weekly Recap - JIT Infrastructure and Documentation Modernization
  73. Weekly Recap - Performance & Tooling Improvements
  74. Weekly Recap - REPL Enhancements & Infrastructure Updates
  75. Base64 Gets Better and Security Tightens Up
  76. JIT Compiler Gets Major Performance Boost
  77. Code Cleanup and Security Focus
  78. Spring Cleaning & iOS Evolution
  79. Base64 Gets a Major Upgrade
  80. Performance Insights and Platform Polish
  81. Security Fixes and Developer Experience Polish
  82. Error Handling Evolution and Quality of Life Wins
  83. JIT Compiler Gets Frame Pointer Safety & Performance Wins
  84. Complex Numbers Get First-Class Treatment
  85. JIT Optimization Surge and Testing Infrastructure Wins
  86. JIT Gets Smarter and Core Gets Cleaner
  87. Emscripten Takes Center Stage
  88. Base64 Gets a Speed Boost
  89. Documentation Cleanup and Performance Tweaks
  90. Performance & Safety Spring Cleaning
  91. Under the Hood Optimizations and Bug Squashing
  92. Core Stability & Performance Sprint
  93. Security & Performance Power-Up
  94. JIT Optimizations and AsyncIO Fixes
  95. Audio Adventures and Threading Safety
  96. Windows REPL Fix and Performance Wins
  97. Spring Cleaning and Performance Gains
  98. Thread Safety Sprint & Infrastructure Wins
  99. Spring Cleaning and Memory Management Magic
  100. The Great Memory Cleanup Day
  101. Crash Guards and Polish Pass
  102. Security & Performance Polish
  103. The Frozendict Revolution
  104. Security Fixes and Memory Magic
  105. Security Fixes and Memory Management Wins
  106. Spring Cleaning and Bug Squashing Bonanza
  107. Threading Fixes and Build Optimizations
  108. SIMD Speed Boost and JIT Improvements
  109. Documentation Revolution & frozendict Optimizations
  110. Regular Expressions Get Clearer and Core Gets Stronger
  111. Unicode Fixes and Threading Safety Updates
  112. Threading Race Conditions and Developer Experience Wins
  113. Small Fixes, Big Impact
  114. Unpacking Possibilities and JIT Optimizations
  115. Memory and Performance Powerhouse
  116. Subprocess Gets a Speed Boost
  117. Cleaning Up Our Act - Modern Python Gets a Language Makeover
  118. 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. Agent Of Empires Daily 94 episodes
  2. Buzz Transcription 102 episodes
  3. Frigate NVR Updates 242 episodes
  4. Ruby Core Updates 250 episodes
  5. Openharness Daily 67 episodes
  6. Linux Kernel 231 episodes
  7. Homebrew 254 episodes
  8. TypeScript 143 episodes
  9. Ruby on Rails 247 episodes
  10. Redis 222 episodes
  11. Next.js 256 episodes
  12. Vue.js 194 episodes
  13. Rust 227 episodes
  14. Go 240 episodes
  15. VS Code 258 episodes
  16. TailwindCSS 150 episodes
  17. Node.js 252 episodes
  18. Django 244 episodes
  19. React Native 201 episodes
  20. PostgreSQL 243 episodes
  21. Kubernetes 253 episodes
  22. LangChain 238 episodes
  23. Ollama 242 episodes
  24. PyTorch 257 episodes
  25. Maestro Daily 93 episodes
  26. Videorc Daily 87 episodes
  27. Agora Next Updates 274 episodes
  28. Rails Daily 258 episodes
  29. Home Assistant Daily 263 episodes
  30. Linux Kernel Daily 237 episodes
  31. React Daily 154 episodes
  32. AtomVM Daily 21 episodes
  33. Next.js Daily 258 episodes
  34. Pi Mono 138 episodes
  35. OpenClaw 215 episodes
  36. RuView 170 episodes
  37. Godot Daily 203 episodes
  38. Jabref Daily 104 episodes
  39. Jabref Daily 105 episodes
  40. Next Js Daily 93 episodes
  41. Headroom Daily 102 episodes
  42. NativeScript iOS Daily 44 episodes
  43. Navidrome Daily 115 episodes
  44. BlocksBeyondTheStars Daily 83 episodes
  45. Shannon 104 episodes
  46. Rimworld ChickenBatteryCage Daily 1 episode
  47. Eleviewer Daily 1 episode
  48. iCloud Photos Downloader 36 episodes
  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