Node.js

Daily updates from Node.js. Server-side JavaScript and the runtime powering millions of applications.

About this developer podcast

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

  1. TLS Internals Reused for QUIC, and a Wave of Filesystem Edge-Case Fixes

    The biggest change today is architectural — QUIC now reuses the generic TLS pause mechanism from PR #65522, simplifying 0RTT handling — while a cluster of smaller fixes tightens up filesystem, test-runner, and crypto edge cases across…

  2. Chasing Down Correctness Bugs in Certs, Watchers, and Isolates

    Today's activity centers on fixing subtle correctness bugs where reading or copying data destructively broke downstream consumers — from TLS certificate chains to recursive file watching to SQLite changesets — alongside a fresh wave of…

  3. Virtual File Systems Move Toward Production

    The virtual file system effort landed integration points across module loading, single executable applications, and native addons, while several long-standing race conditions in streams, file watching, and node-API were fixed. Together…

  4. Weekly Recap - Concurrency Fixes and New Module Surfaces

    This week's Node.js work centered on fixing concurrency and lifecycle bugs across HTTP/2, streams, and SQLite, while two experimental subsystems — foreign function interface and the virtual file system — took steps toward being…

  5. Crypto Correctness and Streams Cleanup

    Today's activity centers on fixing spec-compliance gaps in crypto export and key handling, alongside a coordinated cleanup of stream and QUIC internals, plus a fresh batch of internal binding typings. Together they point to a…

  6. Cleaning Up After Fast Follows

    Today's activity is dominated by fixes to features that landed just days or weeks ago — builtin module lists, file-backed blobs, and flaky tests all got corrected in near-real-time, alongside a cluster of correctness fixes in streams,…

  7. SQLite Reentrancy Bugs and a Wave of Security Hardening

    Three separate contributors independently found and fixed the same class of bug in node colon SQLite, where a user-supplied getter could close a database mid-call and crash the process, while a parallel batch of crypto and permission…

  8. Closing the Gaps in Streams, Crypto, and Cleanup Order

    Today's Node.js activity centers on fixing subtle correctness bugs found through production edge cases and static analysis, spanning HTTP/2 deadlocks, uninitialized memory in crypto, and teardown-order issues in QUIC and SEA binaries.…

  9. Crypto Gets a Major Overhaul
  10. Hardening Native Boundaries and Cutting File System Overhead
  11. Performance Tuning Across the Stack
  12. Weekly Recap - Performance Tuning Across the Core
  13. The File System Gets a Performance Overhaul
  14. Crypto Cleanup and Feature Flags Grow Up
  15. Hardening Pass Across Permissions, SQLite, and Crash Fixes
  16. Performance Tuning and FFI Hardening
  17. String Encoding Gets a Speed Overhaul, Plus a Cleanup Push
  18. URL Performance Push and Permission Model Hardening
  19. A Big Performance Sweep
  20. Weekly Recap - Hardening Streams, SQLite, and Native Bindings
  21. QUIC Stability Push and a Test Suite Cleanup Wave
  22. SQLite Reentrancy Lockdown and Streaming Performance Push
  23. Hardening the Native Boundaries
  24. Correctness Fixes and a Permission System Overhaul
  25. Boundary Checks and Buffer Safety Take Center Stage
  26. Crash Fixes and Cleanup
  27. Hardening Sqlite, SEA, and the Crypto Boundary
  28. Weekly Recap - Hardening the Native Bridges
  29. SQLite Hardening and QUIC Correctness
  30. Hardening Pass Across Crypto, SQLite, and Process Internals
  31. Hardening Streams, FFI, and the Windows I/O Path
  32. Crash Fixes Take Center Stage
  33. Hardening Sweep Across Network, Crypto, and FFI
  34. HTTP Internals Get a Rework
  35. FFI Hardening and Crypto Key Loading
  36. Weekly Recap - Hardening the Foreign Function Interface and Locking Down Runtime Safety
  37. Runtime Deprecations and Task Runner Hardening
  38. DTLS Cleanup, New Zip Support, and a Streaming Performance Push
  39. Locking Down the FFI Fast Path
  40. Security Backports and a Push to Simplify Core
  41. Async APIs Grow, Memory Leaks Shrink
  42. URL Pattern Cleanup and Crash Fixes in SQLite and Streams
  43. Crypto Hardening and a Cluster of Security Fixes
  44. Weekly Recap - Streams, SQLite, and Native Stability Hardening
  45. Boundary Checks and Crash Fixes Take Center Stage
  46. Networking Gets Transferable, Test Suite Gets Stable
  47. QUIC Hardening and a Wave of Stream Bug Fixes
  48. Closing the Gaps Between Fast Paths and Correct Behavior
  49. Crypto Cleanup and the Cost of Cutting Corners
  50. Edge Case Cleanup Across Core Modules
  51. Zlib Validation Sweep and REPL Gets an Upgrade
  52. Weekly Recap - Streams Get Faster, REPL Gets Smarter
  53. Streams Get a Correctness Sweep
  54. Symlinks, Signatures, and the Virtual File System Cleanup
  55. Memory Safety Sweep Ahead of the Jod LTS Cutoff
  56. Streams Get a Correctness and Speed Pass
  57. HTTP Response Handling Gets a Do-Over
  58. Chasing Down Memory Leaks Across the Stack
  59. Streams and Sockets Get a Performance Pass
  60. Weekly Recap - Streams Get Faster, Threads Get Closer
  61. Streams Get Faster, Maps Get Fixed
  62. Streams Get Faster and Safer
  63. Native Fast Paths and Filesystem Hardening
  64. Crypto Cleanup, QUIC Refactors, and Stream Correctness Fixes
  65. The Great Performance Squeeze
  66. Crash Fixes Take Center Stage
  67. Streams Get a Speed Pass, Plus Security Hardening
  68. Weekly Recap - Streams Get Faster, Networking Gets Safer
  69. Stream Iterator Hardening and QUIC Stability Push
  70. Streams Get Faster, Correctness Gets Cleaner
  71. Permission Model Patches and HTTP Correctness Fixes
  72. Error Handling and Build Stability Fixes
  73. Weekly Recap - Performance Optimization & Module System Evolution
  74. Security Fixes and Performance Improvements
  75. Performance Optimizations and Package Resolution Updates
  76. Performance Optimizations and Platform Expansion
  77. Network Security and HTTP/3 Progress
  78. Security Updates and Stream Stability Fixes
  79. Security and Reliability Fixes
  80. Stream Cancellation and Code Quality Improvements
  81. Weekly Recap - Reliability & Developer Experience
  82. Developer Experience Improvements and Security Hardening
  83. Testing Improvements and Legacy Code Cleanup
  84. Critical Stability and Performance Fixes
  85. TypeScript Integration and Runtime Stability
  86. V8 Integration and Platform Stability
  87. Stream Reliability and Debugging Improvements
  88. Negative Zero Fixes and HTTP/2 Stream Improvements
  89. Weekly Recap - Performance Optimizations & Core Infrastructure
  90. Virtual File System and HTTP Header Updates
  91. TypeScript Coverage and HTTP/2 Session Fixes
  92. Security Fixes and Developer Tools Update
  93. WebCrypto Improvements and Security Fixes
  94. QUIC Security Enhancements and Test Improvements
  95. Virtual File System and WebCrypto Security Updates
  96. Weekly Recap - Virtual File Systems and WebCrypto Security
  97. npm 11.15.0 Update and Stream Improvements
  98. QUIC Enhancements and Stream Fixes
  99. WebCrypto Updates and Windows Build Optimization
  100. Stream Fixes and Dependencies Update

Episode archive for Node.js

  1. Temporal Integration and Test Fixes
  2. Streams Performance and Test Runner Stability
  3. Stream Performance and Stability Updates
  4. Weekly Recap - Streams Performance & HTTP Protocol Enhancements
  5. Debugger and Streaming Improvements
  6. Stream Performance and Backpressure Fixes
  7. LTS Release and API Improvements
  8. macOS Security and Build Improvements
  9. Test Runner Tags and Debugger Improvements
  10. Documentation Cleanup and Large PR Guidelines
  11. WebAssembly Exception Fix and Platform Updates
  12. Inspector Storage Support and Crypto Backports
  13. Security Fixes and Platform Updates
  14. The Big 26.0 Release - Temporal API, V8 Updates, and QUIC Implementation
  15. Major Version 26.0.0 Release and Development Updates
  16. WebIDL Refactor and HTTP Drain Fixes
  17. Weekly Recap - Core Stability & Developer Experience
  18. Inspector Network Fixes and Crypto Improvements
  19. HTTP Parser and Tooling Updates
  20. Code Reorganization and Temporal Integration
  21. Build Fixes and Security Patches
  22. Weekly Recap - Security Hardening & HTTP Improvements
  23. HTTP Performance Updates and V8 Profiling Features
  24. Security Fixes and Crypto Improvements
  25. Inspector Stability and Test Runner Improvements
  26. Cryptography Updates and Stream Fixes
  27. Weekly Recap - Web Standards & Developer Tools
  28. API Enhancements and Infrastructure Updates
  29. Web API Standards Compliance and AIX Clang Support
  30. Weekly Recap - SQLite Integration & Test Infrastructure
  31. Documentation and Crypto Improvements
  32. File System Enhancements and QUIC Protocol Updates
  33. QUIC Performance Overhaul and Inspector Improvements
  34. Weekly Recap - Performance Optimizations & Test Framework Enhancements
  35. Pipeline Fixes and Stream Docs
  36. Request Signals and Crypto Powerups
  37. Testing Gets a Major Randomization Upgrade
  38. Test Runner Gets Smarter & Module Evolution Continues
  39. The Great Crypto Unification
  40. Cryptography Upgrades and Stability Fixes
  41. Performance Wins and Crypto Cleanup
  42. AsyncLocalStorage Gets a Modern Makeover
  43. Performance Powerhouse Plus Stream Iteration Magic
  44. Stepping Into the Future with OpenSSL 4.0
  45. Crypto Keys Get Raw and REPL Gets Refined
  46. Major Security Release and Core Infrastructure Updates
  47. Opening Doors for Native Addons
  48. Spring Security Cleanup & Testing Wins
  49. Spring Cleaning and Crypto Changes
  50. Web Standards & Platform Polish
  51. Testing Gets Serious and Dependencies Get Fresh
  52. Cleaning Up the Documentation House
  53. Observability Gets Stronger with Web Locks Diagnostics
  54. Security Hardening & Spring Cleaning
  55. Crypto Standards and REPL Flexibility
  56. Crypto Gets a Major Cleanup
  57. Single Executable Applications Get Faster
  58. Spring Cleaning and Dependency Updates
  59. Performance Boost and Developer Experience Polish
  60. Small Fixes, Big Impact
  61. Modernizing the Stack - REPL Gets a Major Overhaul
  62. Release Day Double Feature & Critical Stream Fixes
  63. Race Conditions and Polish Day
  64. Version 25.8.0 Drops with Security and Performance Wins
  65. Security First - Hooks, Headers, and Hardening
  66. Spring Cleaning and Dependency Updates
  67. TLS Gets Some Love & TypeScript Tools Shine
  68. Spring Cleaning Edition - TypeScript Flags, Performance Boosts, and SQLite Limits
  69. Documentation Pipeline Revolution
  70. Permission Model Gets an Audit Mode Upgrade
  71. Testing Gets Smarter with Worker IDs and Performance Wins
  72. Architecture Fixes & Toolchain Updates
  73. Speed and Efficiency Wins
  74. Spring Cleaning and Speed Boosts
  75. Build System Brilliance and ESM Evolution
  76. Modernizing Documentation with V8's Latest Features
  77. Better Testing and HTTP/2 Reliability Improvements
  78. Documentation Polish and Code Quality Wins
  79. Testing Gets Smarter with Stack Frame Cleanup
  80. Timing is Everything - Fixing Race Conditions and Windows Woes
  81. Performance Push and Polish
  82. Performance Wins and Testing Love
  83. Stream Power-Up and Security Hardening
  84. Storage Inspector and the Great npm Upgrade
  85. Storage Inspector and Developer Experience Upgrades
  86. QUIC Goes Conditional & Buffer Gets Universal
  87. Stream Performance Revolution & Cache Optimization Day
  88. SQLite Gets Stronger & Security Updates Galore
  89. Stability & Security Sweep
  90. Test Runner Renaissance

More public developer podcasts

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

  1. Next Js Daily 54 episodes
  2. Headroom Daily 63 episodes
  3. Agent Of Empires Daily 54 episodes
  4. Frigate NVR Updates 197 episodes
  5. Linux Kernel 188 episodes
  6. Homebrew 209 episodes
  7. TypeScript 98 episodes
  8. Ruby on Rails 202 episodes
  9. Redis 177 episodes
  10. Next.js 211 episodes
  11. Vue.js 150 episodes
  12. Rust 181 episodes
  13. Ruby Core Updates 204 episodes
  14. Python 194 episodes
  15. Go 194 episodes
  16. VS Code 212 episodes
  17. Django 198 episodes
  18. React Native 155 episodes
  19. PostgreSQL 198 episodes
  20. Kubernetes 207 episodes
  21. LangChain 192 episodes
  22. Ollama 196 episodes
  23. PyTorch 211 episodes
  24. Openharness Daily 26 episodes
  25. Maestro Daily 53 episodes
  26. Navidrome Daily 72 episodes
  27. Next.js Daily 213 episodes
  28. Pi Mono 93 episodes
  29. OpenClaw 170 episodes
  30. RuView 131 episodes
  31. Godot Daily 158 episodes
  32. Agora Next Updates 228 episodes
  33. Rails Daily 212 episodes
  34. Home Assistant Daily 217 episodes
  35. Linux Kernel Daily 193 episodes
  36. React Daily 109 episodes
  37. Jabref Daily 64 episodes
  38. BlocksBeyondTheStars Daily 46 episodes
  39. Jabref Daily 65 episodes
  40. Videorc Daily 53 episodes
  41. Shannon 83 episodes
  42. iCloud Photos Downloader 27 episodes
  43. Onlook Design Updates 34 episodes
  44. Buzz Transcription 80 episodes
  45. The Algorithm Daily 15 episodes
  46. TailwindCSS 119 episodes
  47. AtomVM Daily 15 episodes
  48. NativeScript iOS Daily 26 episodes
  49. Agora Next Daily 12 episodes
  50. Energy Inc Ace Mate Learning Daily 2 episodes
  51. tiny-gpu Daily 20 episodes
  52. OpenAI Skills 52 episodes
  53. Crush Daily 1 episode
  54. ControlNet Daily 0 episodes
  55. FinceptTerminal Daily 0 episodes