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. Fused MoE Kernels and Native Reductions

    Activity clusters around single-kernel fusion for Mixture-of-Experts GLU blocks and native ahead-of-time coverage for CUDA reductions, plus Intel backend consolidation and Inductor hot-path trims.

  2. CPU Backend Port and Attention Hardening

    Four linked ports move Intel LSTM, normalization, pooling and softmax kernels off the legacy ideep library, while a Flex GEMM stack plus attention fixes harden GPU matrix and transformer paths. FSDP, Inductor, and Apple MPS work rounds…

  3. Inductor Layout Freezes, MPS Accuracy, Precompile Hardening

    Inductor tightens layout freeze discipline across GEMM, attention and convolution lowerings, while MPS lands a wave of numerical correctness fixes. Precompile moves toward guaranteed zero-compilation serving, and serialization reverts a…

  4. Distributed Goes Public and Precompile Hardens

    Distributed work dominates with a six-part docs reorganization, a new stable functional collectives API, and an NCCL2 memory fix. Dynamo precompile activity focuses on making guards portable for serving precompiled artifacts.

  5. Distributed Reliability, Metal Accuracy, Compiler Speed

    Multi-GPU stability dominates today's activity with N-C-C-L teardown, process-group isolation, and host-memory contention fixes, paired with Apple silicon correctness patches and Inductor performance work.

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

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

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

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

Episode archive for PyTorch

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