PyTorch

Track PyTorch development. The machine learning framework powering AI research.

About this developer podcast

PyTorch 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 PyTorch

  1. Inductor Speedups and Dynamo Correctness Push

    Inductor work cut scatter contention and memory traffic while Dynamo tightened dictionary semantics, and a cluster of distribution fixes corrected edge-case math. C++ FakeTensor migration work continued in the background.

  2. Weekly Recap - Release Hardening Meets Compiler Correctness

    PyTorch focused on stabilizing the 2.15 release branch while advancing compiler correctness in Dynamo and Inductor. Backend work improved Apple silicon, Intel accelerator, and distributed training efficiency.

  3. Dynamo Edge Cases and Precompile Hardening

    Dynamo landed a cluster of correctness fixes for Python containers and edge semantics, while precompile hardened installed-artifact serving for concurrency and error handling. MPS, Inductor, and distributed sharding added targeted…

  4. Inductor Fusion Push and Public Collectives

    Inductor dominates with nested-reduction fusion fixes and a shift to module-level Triton kernels, while distributed promotes functional collectives to a public, compilable API. Dynamo tightens internals and precompile flips to Dynamo by…

  5. Distributed Reliability and Compile Overhead Cuts

    Distributed fixes dominate, tackling cross-group signal interference, store hangs at scale, and idle communicator memory. A parallel Dynamo and Inductor push trims warm-cache compile overhead while fixing silent pattern-rewrite drops.

  6. Compiler Memory Cleanup and Distributed Savings

    A large Inductor stack tackles memory retention and recompilation costs while fusing more work into matrix-multiply kernels, and distributed changes cut FSDP2 complexity and collective test time. The pattern is efficiency: less memory…

  7. Dynamo Object Defaults, Release Cleanup, and Test Visibility

    Dynamo dominates with Python 3.10 removal and true object defaults for repr, string, and comparison to cut graph breaks. Release 2.15 reverts, Inductor strict numerics fixes, and new crash reporting round out a reliability-focused day.

  8. Inductor Correctness Fixes and Regional Graph Control

    Inductor fixed silent numerical divergences in pattern matching and strict-mode operations while adding safer performance tuning. Dynamo consolidated its internal tracking logic, and distributed tests got major speedups as the 2.15…

  9. All-Gather Showdown and Stack-Aware Merges
  10. Weekly Recap - FSDP Contracts, MPS Speedups, and Compiler Fidelity
  11. Compiler Parity Push
  12. Distributed Hang Fixes and Compiler Hardening
  13. Low-Precision Grouped GEMM Push and Compiler Fixes
  14. Block Sharding for MoE, Collective Transparency, and Inductor Fixes
  15. GEMM Fusion and Portable CUDA Graphs
  16. Precompile Groundwork and Compiler Reliability Fixes
  17. Compiler Correctness and Precompile Hardening
  18. Weekly Recap - Precompile Scale, Mac Reliability, and Compiler Fixes
  19. Precompile for Serving, Faster First Compile, MPS Correctness
  20. CI Pod Cleanup and Compiler Correctness
  21. Dynamo Fidelity, MPS Scale, and CI Moves
  22. SVD Fixes, Compiler Safety, and Export Hardening
  23. Device-Agnostic Tests, Inductor Reliability, and GPU Partitioning
  24. Precompile Goes Default, Dynamo Tightens Correctness
  25. Dynamo Guards Hardening and Precompile Push
  26. Weekly Recap - Precompile Goes Public and Guards Become Portable
  27. Precompile Interface and Guard Packaging Hardening
  28. The Great Distributed Test Speedup
  29. Compile Regions Get Finer Control
  30. Test Infrastructure Gets a Deep Clean
  31. Sharding, Fake Tensors, and the Great Test Cleanup
  32. Correctness Fixes and the AOT Compile Hardening Push
  33. Compile-On-One-Rank Gets Serious About Device Portability
  34. Weekly Recap - Compiler Correctness and MPS Backend Consolidation
  35. Apple Silicon Hardening and Dynamo's Global State Cleanup
  36. Hardening the Compile-and-Ship Pipeline
  37. Distributed Training Takes Control of Its Own Timing
  38. Guard Serialization Gets a Precision Pass
  39. Inductor's Reduction Fusion Overhaul
  40. Hardware Independence Takes Center Stage
  41. Hardware-Agnostic Cleanup and MPS Correctness Push
  42. Weekly Recap - Multi-Rank Compilation and Backend Correctness
  43. One Rank to Compile Them All
  44. Dynamo Closes Its Torch Function Gaps
  45. Precompile Gets a Real Foundation
  46. Cleaning Up Exceptions, Symbolizers, and Inductor's Blackwell Push
  47. Distributed Transports, Compiler Correctness, and the Aches of Reference Counting
  48. Memory Safety and Lifetime Fixes Across CUDA and Distributed
  49. Precompile Lands, and the Correctness Sweep Continues
  50. Weekly Recap - Precompile Lands, and Correctness Sweeps Across MPS and CUDA
  51. Batching Rules Get Unified, Precompile Gets Sharper
  52. Undefined Contracts and the MPS Coverage Push
  53. A New CuteDSL Reduction Engine and the Great Test Untangling
  54. ROCm Ten Point Oh and the Precompile Stack
  55. Hardening the Merge Pipeline and the Attention Stack
  56. FlyDSL Lands and the GEMM Compiler Stack Grows
  57. AOT Autograd Tightens Its Grip on Backward Tangents
  58. Weekly Recap - Compiler Correctness and the Long Tail of Cleanup
  59. Precompile Guards Get a Rewrite
  60. Precompile Hardening and the Great Cleanup
  61. Precompile's Guard Overhaul
  62. Compiler Stacks, Symmetric Kernels, and Build Hygiene
  63. Precompile Grows Up, and the Great Typo Sweep
  64. Correctness Cleanup and a Suspicious Cluster
  65. Numerical Correctness Sweep
  66. Weekly Recap - Release Stabilization and Dynamo's Object Model Overhaul
  67. Dynamo's Great Untangling
  68. Attention Backend Correctness and CI Coverage Gaps
  69. The Great Hardware Decoupling
  70. The Great Device-Agnostic Test Rewrite
  71. Release Branch Cleanup and the Great Test Decoupling
  72. The Great Test Reclassification
  73. The Great Test Suite Decoupling
  74. Weekly Recap - Test Infrastructure Overhaul and Correctness Fixes
  75. The Great NaN and Negative Zero Cleanup
  76. Closing the GPU Test Coverage Gap
  77. The Great Device-Agnostic Test Migration
  78. Hardening Distributed Communication and Cutting Legacy Support
  79. Test Debt, GPU Correctness, and the Long Tail of Cleanup
  80. Distributed Backend Correctness Overhaul
  81. Boundary Checks and the Hardware-Agnostic Test Push
  82. Weekly Recap - Silent Correctness Fixes Take Center Stage
  83. Silent Corruption Sweep
  84. Compiler Internals Get Hardened Ahead of Bigger Changes
  85. Distributed Backends Get Serious About Parity
  86. A GEMM Epilogue Megastack and Distributed Hardening
  87. Cleaning Up the Compiler's Noise
  88. Crash Fixes and NCCL's Next Chapter
  89. Compiler Correctness Meets Test Portability
  90. Weekly Recap - Performance Fixes and Toolchain Modernization
  91. Toolchain Upgrades and Correctness Fixes Across the Stack
  92. Native Kernel Push and Distributed Backend Parity
  93. Correctness Hardening Across Inductor and AOTI
  94. The NVGEMM Epilogue Fusion Marathon
  95. Distributed Correctness Push
  96. CUDA Graphs Get a Lifecycle, Distributed Gets Cleaned Up
  97. One Engineer, Many Kernels
  98. Weekly Recap - Cleanup, Correctness, and a Random Number Overhaul
  99. Cleanup Sweeps and a New RNG Foundation
  100. Hardening Memory and Lifetime Management Across GPU Backends

Episode archive for PyTorch

  1. Correctness Fixes and Reverts Take Center Stage
  2. Distributed Backends and Overflow Fixes Take Center Stage
  3. Packaging Fixes and Bounds-Check Sweep
  4. Autograd Overhead Cuts and a New GEMM Backend Migration
  5. Hardening Boundary Checks and MPS Correctness
  6. Weekly Recap - Metal Kernels, Compile Reliability, and Dynamo's Long Tail
  7. Apple Silicon Gets a Metal Overhaul
  8. Dynamo's Great Type-System Cleanup
  9. Dynamo's CPython Test Push and a Rocky Exception-Handling Rewrite
  10. Distributed Backend Overhaul and a Wave of Cleanup
  11. The Great Runner Migration, and a Distributed Rollback
  12. Distributed Cleanup and CI Infrastructure Overhaul
  13. Correctness Fixes Sweep the Compiler Stack
  14. Weekly Recap - Release Hardening and Correctness Cleanup
  15. Determinism and Correctness Sweep
  16. Silent Correctness Bugs Take Center Stage
  17. FlexAttention's Rough Week
  18. Accelerator Backends and Memory Management
  19. Weekly Recap - Release Stabilization & Core Improvements
  20. GEMM Optimization and Core Stability Fixes
  21. C++20 Migration and Infrastructure Improvements
  22. Release Infrastructure and Compiler Stability Fixes
  23. Header Reorganization and Dynamo Improvements
  24. Infrastructure Organization and Core API Cleanup
  25. Dynamo Correctness and Build Infrastructure
  26. Performance Optimizations and Backend Improvements
  27. Weekly Recap - Compiler Optimization & Reliability
  28. Dynamo Compilation Stability and Performance
  29. Dynamo Stability and Inductor Optimizations
  30. Compiler Performance and Distributed Computing Infrastructure
  31. Distributed Naming Overhaul and Compiler Fixes
  32. Dynamo Stability and Compilation Robustness
  33. Compiler Numerical Accuracy and Index Expression Fixes
  34. Compiler Error Handling and Stability Fixes
  35. Weekly Recap - Stability and Error Handling Improvements
  36. Weekly Recap - Code Quality & Infrastructure Improvements
  37. Weekly Recap - Dynamo Enhancements & Critical Fixes
  38. Optimization Engine Revamp and Hash System Breakthrough
  39. Operator Improvements and Build System Updates
  40. Weekly Recap - Reverts and Infrastructure Updates
  41. Inductor Improvements and Bug Fixes
  42. Optimization Improvements and Cache Unification
  43. Weekly Recap - Performance Optimizations and Code Cleanup
  44. Weekly Recap - Infrastructure Stability & Mixed Precision
  45. Dynamo Improvements and Distributed Computing Fixes
  46. Weekly Recap - Performance Optimization and Infrastructure
  47. The Debugging Detective Story
  48. The Great Rollback and Recovery
  49. Exception Handling Revolution & Stateless RNG Arrives
  50. Cross-Platform Expansion and Developer Experience Wins
  51. Building Stronger Foundations
  52. Spring Cleaning & Major Infrastructure Upgrades
  53. AOT AutoGrad Fixes and Cross-Platform Polish
  54. Building Bridges - Distributed Computing Gets a Major Upgrade
  55. Profiling Power-Ups and Infrastructure Smoothing
  56. Fixes, Reverts, and Moving Forward
  57. The Infrastructure Acceleration Edition
  58. Lanczos Interpolation Breakthrough
  59. Stream Management Mastery & RNG Fixes
  60. Matrix Math Gets a Speed Boost
  61. Under the Hood Improvements and Future-Proofing
  62. Complex Math Gets Smarter & Build Improvements
  63. Memory Optimization Revolution
  64. Testing Gets Smarter and Graphs Go Universal
  65. Polish & Performance Day
  66. Distributed Computing Gets Real - Compilation, Clustering, and Convolutions
  67. Performance Revolution and Developer Experience Upgrades
  68. Windows Testing Gets Flexible & Dynamic Shapes Take Flight
  69. Metal Shaders Get a Precision Fix
  70. The Testing & Error Handling Polish Episode
  71. Stream Safety and Performance Wins
  72. Subclass Evolution and Memory Management Improvements
  73. Performance Tuning and Code Health Day
  74. Variable-Length Attention Gets Supercharged
  75. Spring Cleaning and Performance Boosts
  76. Stream Wizardry and Symbolic Shapes Magic
  77. CI Optimizations and Cross-Platform Fixes
  78. Spring Cleaning and Precision Fixes
  79. Memory Safety Fixes and Development Velocity
  80. Speed Wins and Better Error Messages
  81. Distributed Computing Gets Smarter
  82. Distributed Computing Gets Smarter & Vision Models Get Lightning Fast
  83. Release Dance and Rapid Recovery
  84. Performance Wins and Stability Fixes
  85. Distributed Computing Gets Smarter
  86. Valentine's Day Cleanup and Distributed Computing Love
  87. The Day of Rollbacks and Second Chances
  88. TPU Integration and the Dance of Reverts
  89. The Performance Optimization Sprint
  90. The Great Performance Revolution - Tests Run 70% Faster!
  91. Bug Fixes and Performance Wins
  92. The Great Test Speed Revolution
  93. Cleanup and Optimization Day
  94. Testing Cleanup and Pattern Matching Progress
  95. Type Safety Revolution and Infrastructure Cleanup
  96. Backend Flexibility Revolution
  97. The Great Configuration Cleanup & XPU Expansion
  98. Hardware Expansion and Developer Experience Polish
  99. Backend Harmony and Memory Magic
  100. Spring Cleaning and Building Blocks
  101. Bytecode Magic and Buffer Management Mastery
  102. Kernel Optimization and Clean Code Victory
  103. FMA Optimization Focus and Debugging Improvements
  104. Developer Tooling Revolution
  105. Deep Dive into PyTorch's Core - Opaque Objects and Performance Wins

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. Python 240 episodes
  15. Go 240 episodes
  16. VS Code 258 episodes
  17. TailwindCSS 150 episodes
  18. Node.js 252 episodes
  19. Django 244 episodes
  20. React Native 201 episodes
  21. PostgreSQL 243 episodes
  22. Kubernetes 253 episodes
  23. LangChain 238 episodes
  24. Ollama 242 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