Ruby Core Updates

Daily updates from the Ruby programming language core. Track the evolution of Ruby with insights into new features, optimizations, and language improvements.

Daily RSS feed

Weekly RSS feed

https://podlog.io/listen/ruby-core-updates-d085d600

Episodes

  1. Ruby Core Updates: ZJIT Optimization Push and Documentation Improvements

    Ruby's ZJIT compiler received significant optimization improvements focused on better type inference and memory layout handling, while the documentation team added comprehensive guides for file operations. The RubyGems integration was…

  2. Ruby Core Updates: Performance Optimizations and Infrastructure Improvements

    Ruby's latest changes focus heavily on performance improvements across ZJIT compilation and RubyGems dependency resolution, alongside critical infrastructure updates for build systems and signal handling stability.

  3. Ruby Core Updates: Weekly Recap - JIT Optimization and Core Infrastructure

    Ruby's JIT compilation received significant performance improvements this week, with Aaron Patterson's object layout optimization work taking center stage alongside continued ZJIT development. The team also focused on garbage collection…

  4. Ruby Core Updates: Garbage Collection Optimizations

    Recent Ruby core changes focus heavily on garbage collection performance improvements, with two targeted optimizations reducing redundant function calls in hash processing and modular GC compilation. Additional updates include a…

  5. Ruby Core Updates: JIT Optimization and Object Layout Changes

    Six pull requests were merged on May 29th focusing on JIT compiler improvements and object layout optimization. A significant object layout change was merged and immediately reverted, while ZJIT received multiple performance and cleanup…

  6. Ruby Core Updates: JIT Optimizations and Marshal Security Fixes

    Five pull requests merged focused on JIT compiler improvements and data layout unification, with additional commits addressing RubyGems security vulnerabilities and JSON parser edge cases.

  7. Ruby Core Updates: ZJIT Refactoring and Code Cleanup

    Ruby Core merged nine pull requests on May 27th, 2026, focusing heavily on ZJIT performance improvements, code cleanup, and bug fixes. The changes include significant refactoring of ZJIT's operand handling and stack layout normalization…

  8. Ruby Core Updates: String Performance and Security Fixes

    Four pull requests merged with notable String#scrub performance improvements and security fixes for gem extraction. Additional RubyGems updates address concurrent installation issues and directory permissions.

  9. Ruby Core Updates: CI Optimization and Documentation Improvements

    Two pull requests were merged focusing on GitHub Actions workflow optimization and gem synchronization requirements. Additional commits included significant RubyGems documentation updates and minor bug fixes.

  10. Ruby Core Updates: Documentation Fixes and Memory Management Improvements

    Three documentation pull requests were merged fixing Hash comparison examples, Proc binding documentation, and error messages. A significant commit introduces a new CPU-based heap sizing mode for the MMTk garbage collector.

  11. Ruby Core Updates: Weekly Recap - ZJIT Optimization & Performance Improvements

    This week saw significant ZJIT compiler improvements with native stack optimizations and function call reductions. The team also delivered notable performance enhancements to String#codepoints and fixed critical GC compaction issues.

  12. Ruby Core Updates: ZJIT Improvements and String Performance

    Ruby's JIT compiler received significant architectural improvements with native stack storage changes, while String#codepoints gained ASCII optimization for multi-byte strings. Several documentation updates for Pathname methods were also…

  13. Ruby Core Updates: JIT Compiler Fixes and GC Improvements

    Ruby Core merged 19 pull requests addressing critical JIT compiler bugs, GC compaction issues, and CI infrastructure improvements. Key fixes include ZJIT exit tracing, YJIT register overflow, and compare-by-identity set compaction problems.

  14. Ruby Core Updates: CI Workflow Cleanup and Memory Management

    Ruby core developers merged 15 pull requests focused on streamlining CI workflows and improving memory management. Major changes include tarball workflow cleanup, new monotonic counters for malloc tracking, and fixes for protected method…

  15. Ruby Core Updates: Refinement Fixes and CI Improvements

    Jeremy Evans fixed critical refinement handling bugs in Method#super_method that caused infinite loops and incorrect lookup behavior. The team also streamlined CI workflows and addressed security vulnerabilities in IO::Buffer operations.

  16. Ruby Core Updates: Security Fixes and Testing Infrastructure Overhaul

    Ruby core merged 16 pull requests focusing on critical security fixes including use-after-free vulnerabilities in IO::Buffer operations and refinement method handling improvements. Major testing infrastructure updates consolidated…

  17. Ruby Core Updates: Memory Safety and Performance Optimizations

    Ruby Core merged eight pull requests focusing on memory safety fixes and internal optimizations, including critical buffer security patches and hash table performance improvements.

  18. Ruby Core Updates: Refinement Fixes and Documentation Improvements

    Ruby core merged 15 pull requests focused on refinement method fixes, ZJIT optimizations, and extensive Pathname documentation updates. Key changes include prohibiting super calls in refined module methods and resolving Windows CI…

  19. Ruby Core Updates: Weekly Recap - Refinements & Infrastructure Improvements

    This week brought 20 merged pull requests and 30 additional commits, featuring significant refinement fixes, ZJIT optimizations, and extensive documentation updates. Key highlights include a fix for super usage in refined methods and…

  20. Ruby Core Updates: ZJIT Optimizations and Bug Fixes

    Nine pull requests were merged including ZJIT memory optimizations for C method frames and a critical segfault fix in Thread.each_caller_location. Additional updates include OpenSSL 3.3.3 backport and documentation improvements.

  21. Ruby Core Updates: Memory Optimization and Security Fixes

    Ruby core merged 17 pull requests focusing on memory allocation improvements for MatchData objects and fixing critical security vulnerabilities. Notable changes include embedded T_MATCH storage allocation and resolution of use-after-free…

  22. Ruby Core Updates: JIT Improvements and Class System Refactoring

    Ruby Core merged 20 pull requests focusing on ZJIT compiler optimizations, a major refactoring of the class inheritance system, and OpenSSL security updates. The changes include memory optimizations and performance improvements for the…

  23. Ruby Core Updates: ZJIT Optimizations and Bug Fixes

    Ruby's development team merged 13 pull requests with significant ZJIT compiler improvements and critical bug fixes for garbage collection and IO operations. Major changes include ZJIT basic block restructuring and fixes for…

  24. Ruby Core Updates: Regexp Validation and GC Improvements

    Ruby developers merged two critical fixes addressing NaN timeout validation in regular expressions and optimizing class extension garbage collection performance. Additional commits included JSON generator security improvements and…

  25. Ruby Core Updates: String Methods and Scheduler Fixes

    Six pull requests were merged addressing string unpacking, rational parsing, and scheduler stability issues. Notable changes include negative offset support for String#unpack methods and critical fiber scheduler fixes.

  26. Ruby Core Updates: Box Architecture Overhaul and Fiber Scheduler Fix

    Ruby's core team merged significant changes to the box system architecture, separating master and root boxes for better isolation, plus a critical garbage collection fix for fiber schedulers.

  27. Ruby Core Updates: Performance Optimizations and ZJIT Improvements

    Ruby Core merged 8 pull requests on May 8th, featuring significant performance improvements to Integer#to_s conversion and continued development of the ZJIT compiler infrastructure.

  28. Ruby Core Updates: Exception Handling and ZJIT Performance Fixes

    Ruby core merged 10 pull requests addressing exception variable caching issues, ZJIT performance improvements, and various bug fixes. Additional bundler updates improved override handling and configuration management.

  29. Ruby Core Updates: Refinement Fixes and Documentation Improvements

    Seven pull requests merged on May 7th, focusing on a critical refinement zsuper lookup fix and extensive documentation updates for Pathname methods. Additional commits enhanced Bundler's override DSL functionality.

  30. Ruby Core Updates: Shape System Optimization and Documentation Improvements

    Nine pull requests merged on May 6th focused primarily on optimizing Ruby's shape system for instance variables, along with documentation updates for IO methods. Key changes include performance improvements to instance variable caching…

  31. Ruby Core Updates: Performance and Memory Management Improvements

    Ruby Core merged 15 pull requests focused on garbage collection optimization, shape caching improvements, and documentation enhancements. Key changes include simplified GC object movement, refactored instance variable caches, and…

  32. Ruby Core Updates: Coverage Module and GC Improvements

    Ruby developers merged 9 pull requests focused on fixing coverage support for compiled instruction sequences and introducing a new write barrier validation tool. Key improvements include coverage module fixes and ZJIT optimizations.

  33. Ruby Core Updates: Weekly Recap - Shape System Optimization & Memory Performance

    This week brought significant internal improvements with 20 pull requests focused heavily on shape system optimization and memory efficiency. Major work included shape transition refactoring, JIT compiler enhancements, and several…

  34. Ruby Core Updates: Shape System Optimization and Documentation Improvements

    Seven pull requests merged on May 3rd, 2026, featuring significant shape system refactoring by Jean Boussier and documentation updates for Pathname and garbage collection methods.

  35. Ruby Core Updates: Shape System Optimization

    Jean Boussier merged five pull requests focused on optimizing Ruby's shape system, reducing memory usage and improving performance through structural improvements to shape trees and object allocation.

  36. Ruby Core Updates: ZJIT Performance Enhancements and Global Variable Fixes

    Three pull requests were merged today focusing on ZJIT optimization, global variable caching fixes, and documentation updates. The most significant change introduces Class#allocate inlining in ZJIT for improved performance.

  37. Ruby Core Updates: Memory Management and Documentation Improvements

    Ruby core saw significant memory management optimizations with IMEMO improvements and ZJIT debugging enhancements, alongside comprehensive documentation updates for File and Set classes.

  38. Ruby Core Updates: JIT Optimizations and String Instruction Refactoring

    Seven pull requests were merged on April 29th, focusing on JIT compiler improvements and a major string instruction rename. Key changes include ZJIT method call optimizations, safer Rust FFI code, and renaming putstring to dupstring…

  39. Ruby Core Updates: Garbage Collection Cleanup and ZJIT Optimization

    Jean Boussier led significant cleanup of garbage collection macros while Nozomi Hijikata optimized ZJIT local variable reloading. The changes remove legacy debugging code and streamline object allocation across Ruby core.

  40. Ruby Core Updates: Garbage Collection API Refinements

    Four pull requests merged today focused on garbage collection improvements and test enhancements. Jean Boussier led efforts to simplify the newobj API and fix memory size calculation compatibility issues.

  41. Ruby Core Updates: Weekly Recap - Memory Safety & Performance Enhancements

    Ruby core focused heavily on memory safety improvements and performance optimizations this week, with 13 merged pull requests addressing critical issues in class variable management, instance variable iteration safety, and ZJIT compiler…

  42. Ruby Core Updates: Memory Safety and Write Barrier Fixes

    John Hawthorn merged three pull requests addressing critical memory safety issues in Ruby's core, including fixes for instance variable handling and write barrier problems. The updates include 12 total commits focused on preventing…

  43. Ruby Core Updates: Array Method Documentation Clarification

    Jean Boussier merged a documentation update clarifying how Ruby's array methods use `eql?` and hash functions differently based on array size for performance optimization.

  44. Ruby Core Updates: API Exposure and RubyGems Security Enhancements

    A new public API for integer parsing was exposed to C extensions, while RubyGems received significant security improvements with options to disable extension building and plugin installation during gem installation.

  45. Ruby Core Updates: ZJIT Refactoring and Library Fixes

    Two ZJIT improvements were merged focusing on code clarity and proper instruction sequence handling, while library updates fixed IPv6 address classification bugs and Ripper compatibility issues.

  46. Ruby Core Updates: C23 Compatibility and ERB Sync

    Two pull requests were merged today addressing C23 compiler compatibility and syncing ERB 4.0.3.1 to the Ruby 3.3 branch.

  47. Ruby Core Updates: Memory Management and Performance Optimizations

    Four pull requests merged on April 21st focused on memory safety improvements and performance optimizations. Key changes include making class variable tables managed objects to prevent memory corruption and optimizing string encoding…

  48. Ruby Core Updates: Weekly Recap - Dependency Management & Performance

    This week brought 30 commits focused on dependency resolution improvements and performance optimizations. Key fixes addressed Bundler's native extension handling and memory leaks in OpenSSL bindings.

  49. Ruby Core Updates: Weekly Recap - Performance Optimizations & Bug Fixes

    This week brought significant performance improvements to hash allocation and memory management, along with critical bug fixes for class duplication and regular expression handling. The ZJIT compiler also received important stability…

  50. Ruby Core Updates: Development Tool Reliability Fix

    Ruby's development tooling received a reliability improvement with a fix for error handling when the lsof system utility is unavailable. The change ensures more robust memory leak detection across different system configurations.

  51. Ruby Core Updates: Weekly Recap - ZJIT Performance and Infrastructure Improvements

    46 pull requests merged with 88 additional commits focused heavily on ZJIT compiler optimizations and Ruby core infrastructure improvements. Major fixes included ractor backtrace handling and memory allocation enhancements.

  52. Ruby Core Updates: ZJIT Performance Optimizations

    Four pull requests merged focusing on ZJIT compiler improvements, including getivar recompilation optimizations and guard instruction deduplication. Performance improvements show ZJIT execution ratio increased from 82.4% to 85.3% on the…

  53. Ruby Core Updates: JIT Compiler Optimizations and Bug Fixes

    Seven pull requests merged on April 2nd and 3rd, primarily addressing YJIT and ZJIT compiler issues, stack overflow problems, and AST parsing bugs. Additional commits focused on test reliability improvements across Windows and macOS…

  54. Ruby Core Updates: Ractor Fixes and JIT Improvements

    Ruby merged 10 pull requests including a fix for backtrace handling across ractors and several ZJIT stability improvements. Additional work included class variable cache fixes and RubyGems JRuby compatibility updates.

  55. Ruby Core Updates: Memory Management and JIT Improvements

    Ruby Core merged 7 pull requests on April 1st, 2026, including public memory allocation APIs and significant ZJIT performance enhancements. Additional commits focused on RubyGems attestation improvements and CI reliability fixes.

  56. Ruby Core Updates: ZJIT Performance Improvements and GC Optimizations

    Ruby's development team merged 15 pull requests focusing heavily on ZJIT compiler optimizations, garbage collection improvements, and CI infrastructure updates. Key changes include new ZJIT configuration options and memory allocation…

  57. Ruby Core Updates: CI Infrastructure Improvements

    Three pull requests merged today focused on fixing cross-compilation builds and resolving CI infrastructure issues, including DockerHub rate limit problems and workflow cleanup.

  58. Ruby Core Updates: Weekly Recap - ZJIT Performance & Core Infrastructure

    ZJIT received major performance improvements including lightweight frames and exit profiling. Core infrastructure saw threading optimizations and fiber pool enhancements alongside developer tooling updates.

  59. Ruby Core Updates: ZJIT Optimization and Developer Tools

    Four pull requests merged to Ruby Core on March 28-29, featuring ZJIT compiler improvements for handling optional parameters and new developer documentation tools. Additional commits included TruffleRuby StringScanner implementation and…

  60. Ruby Core Updates: ZJIT Performance Optimizations and Source Location Revert

    Eleven pull requests merged with major ZJIT performance improvements including lightweight frames and specialized block handling. A significant revert removed source location column and end line information from Ruby methods.

  61. Ruby Core Updates: ZJIT Performance Improvements and CI Stability Fixes

    Ruby core merged 8 pull requests focused on ZJIT compiler enhancements and CI infrastructure improvements. Key changes include compiling setblockparam instructions and parallelizing bundled gems testing.

  62. Ruby Core Updates: ZJIT Optimization and Performance Improvements

    Thirteen pull requests were merged focusing heavily on ZJIT compiler optimizations, including exit profiling for unprofiled method calls and support for negative array indices. Additional improvements include class allocator inheritance…

  63. Ruby Core Updates: ZJIT Performance Enhancements and Regexp Freezing

    Ruby's development team merged 15 pull requests focused heavily on ZJIT compiler optimizations, including new tracing capabilities and polymorphic code generation. A significant change freezes all Regexp instances by default, except for…

  64. Ruby Core Updates: ZJIT Compilation Improvements and Bug Fixes

    Ruby's development team merged 14 pull requests on March 24th, 2026, with significant focus on ZJIT compiler enhancements and several core bug fixes. The updates include new instruction compilation support, polymorphic optimizations, and…

  65. Ruby Core Updates: Documentation Improvements and Bundler Restructuring

    Five pull requests merged focusing on documentation fixes and C extension features, while significant bundler directory restructuring was reverted after testing issues.

  66. Ruby Core Updates: Weekly Recap - JIT Optimization & Performance Enhancement

    This week saw significant advancement in Ruby's JIT compilation with ZJIT receiving a linear scan register allocator and multiple optimization improvements. Major changes included Prism parser restructuring, performance optimizations…

  67. Ruby Core Updates: ZJIT Array Access Optimization

    Aaron Patterson merged a ZJIT optimization that eliminates unnecessary runtime guards for array access with static indices. Additional commits improved Java backend identifier handling in the Prism parser.

  68. Ruby Core Updates: ZJIT Performance Improvements and Prism Parser Updates

    The Ruby core team merged 18 pull requests focused heavily on ZJIT compiler optimizations and Prism parser restructuring. Key improvements include 52% reduction in ZJIT metadata memory usage and significant codegen optimizations.

  69. Ruby Core Updates: ZJIT TracePoint and Subclass Improvements

    Ruby core merged seven pull requests focusing on ZJIT compiler fixes for TracePoint return values and method rescue handling, plus class inheritance optimizations. Additional commits included bundled gem updates and documentation fixes.

  70. Ruby Core Updates: ZJIT Performance and Security Fixes

    Ruby's development team merged six pull requests focused on ZJIT compiler improvements and CI reliability, plus addressed a JSON security vulnerability. Notable changes include ZJIT write barrier optimizations and enhanced testing…

  71. Ruby Core Updates: JIT Compiler Fixes and VM Optimizations

    Ruby's development team merged seven pull requests on March 16th, focusing on critical YJIT bug fixes, new ZJIT debugging features, and VM performance optimizations. The activity included 22 additional commits addressing bundler…

  72. Ruby Core Updates: Weekly Recap - ZJIT Optimization & Parser Modernization

    Ruby core saw significant ZJIT performance improvements and a major shift from AST to Prism parser for built-in loader generation. The team merged 33 pull requests addressing compiler optimizations, threading fixes, and infrastructure…

  73. Ruby Core Updates: Parser Transition and Performance Improvements

    Ruby core merged five pull requests including a significant shift to using Prism parser for builtin loader generation and Apple-specific memory search optimizations. Additional commits included Prism enhancements and test stability fixes.

  74. Ruby Core Updates: ZJIT Optimizations and Prism Compiler Improvements

    Ruby Core merged three significant pull requests focused on ZJIT testing capabilities, performance optimizations, and Prism compiler speed improvements. Additional commits included Bundler installation process enhancements and integer…

  75. Ruby Core Updates: Threading and RubyGems Compatibility Fixes

    Ruby Core merged six pull requests addressing critical threading issues on OpenBSD, RubyGems compatibility improvements, and documentation updates. Additional commits focus on RubyGems extension loading and YAML serialization fixes.

  76. Ruby Core Updates: ZJIT Optimization and Core Fixes

    Four pull requests were merged today, highlighted by a significant ZJIT compiler enhancement that adds string equality optimization with constant folding capabilities. Additional fixes addressed documentation links, pointer conversion…

  77. Ruby Core Updates: ZJIT Optimizations and Zlib Updates

    Ruby's development team merged 8 pull requests focusing on ZJIT performance improvements and zlib library updates across multiple Ruby versions. Additional work included significant RubyGems YAML serialization changes.

  78. Ruby Core Updates: Threading Fixes and Memory Optimization

    Seven pull requests merged with notable fixes for OpenBSD thread support and garbage collection optimizations. Major work includes M:N threading improvements and slot size calculation refactoring.

  79. Ruby Core Updates: Weekly Recap - JIT Optimizations and Bug Fixes

    This week saw significant ZJIT compiler improvements with load-store forwarding optimizations and constant folding enhancements, alongside critical bug fixes for string formatting and method comparison issues.

  80. Ruby Core Updates: JSON Gem Security and Release Update

    The Ruby core team has released JSON gem version 2.19.1 with a critical memory safety fix addressing a missing garbage collection guard in the fbuffer_append_str function.

  81. Ruby Core Updates: ZJIT Performance Enhancements and Bug Fixes

    The Ruby development team merged 10 pull requests on March 7th, 2026, with significant improvements to ZJIT performance monitoring and several critical bug fixes for Ruby 3.4. Key updates include execution counters for JIT-compiled code,…

  82. Ruby Core Updates: ZJIT Optimizations and Prism Parser Improvements

    Eleven pull requests were merged with major focus on ZJIT compiler optimizations including load store forwarding and interrupt checking improvements. The Prism parser received significant memory efficiency upgrades through arena allocation.

  83. Ruby Core Updates: ZJIT Optimization and WeakMap Bug Fix

    Two pull requests were merged including ZJIT compiler improvements and a WeakMap assignment bug fix, along with updates to JSON generation, Prism parser fixes, and zlib security patches.

  84. Ruby Core Updates: JIT Improvements and New ENV Method

    Ruby Core saw significant JIT compiler enhancements with ZJIT bug fixes and new tooling, plus the addition of ENV.fetch_values method. Nine pull requests were merged with focus on performance optimizations and developer tools.

  85. Ruby Core Updates: ZJIT Performance Optimizations

    Five pull requests merged focused primarily on ZJIT compiler optimizations, including improved TypedData ivar handling and reduced allocation overhead. Additional updates include Prism parser fixes and StringIO frozen object improvements.

  86. Ruby Core Updates: Parser Refactoring and Lrama 0.8.0

    Ruby's parser received significant refactoring with argument list improvements, while the Lrama parser generator was updated to version 0.8.0. Additional changes included GitHub Actions security improvements and test dependency fixes.

  87. Ruby Core Updates: GitHub Actions Security Hardening

    The Ruby core team merged security improvements to GitHub Actions workflows using the zizmor tool, alongside a minor test cleanup. The changes span 34 files and focus on hardening CI/CD security practices.

  88. Ruby Core Updates: ZJIT Optimizations and Error Handling

    Ruby's development activity focused heavily on ZJIT compiler optimizations, with five pull requests refining instruction effects and memory handling. Additional improvements include better Ractor error messages and memory allocation…

  89. Ruby Core Updates: Memory Management and Parser Enhancements

    Two pull requests were merged focusing on garbage collection fixes and documentation automation, while additional commits added support for trailing commas in method signatures and improved heredoc handling in the Prism parser.

  90. Ruby Core Updates: ZJIT Improvements and Documentation Fixes

    Ruby developers merged six pull requests on February 21-22, focusing on ZJIT stabilization improvements, CI workflow updates, and documentation corrections across manual pages and JIT documentation.

  91. Ruby Core Updates: YJIT Memory Safety and GC Improvements

    Ruby developers merged critical fixes for YJIT memory safety issues and garbage collection optimizations. The updates address use-after-free vulnerabilities and remove unnecessary bitmap alignment code.

  92. Ruby Core Updates: Prism Integration and Performance Enhancements

    Six pull requests were merged focused on Prism parser improvements and ZJIT performance monitoring. Notable changes include integrating Ruby's allocator with Prism and adding side-exit tracking to ZJIT.

  93. Ruby Core Updates: Major Performance and API Enhancements

    Ruby Core merged 15 pull requests including Monitor becoming a core class for better performance, new LEB128 encoding support, and autoload_relative functionality. Additional commits focused on Rust gem improvements and bundler…

  94. Ruby Core Updates: ZJIT Performance Improvements and Method Equality Fix

    Ruby Core merged seven pull requests focused on ZJIT JIT compiler optimizations and a critical UnboundMethod equality bug fix. The updates include significant performance improvements to type inference and better test infrastructure.

  95. Ruby Core Updates: Documentation Fixes and JSON Performance Improvements

    Three pull requests were merged focusing on documentation corrections and build process improvements, while additional commits included JSON parser optimizations and RubyGems enhancements.

  96. Ruby Core Updates: Test Reliability and Performance Fixes

    Ruby core developers merged 13 pull requests focused on improving test reliability and fixing timeout issues across multiple test suites. Key changes include Ractor performance optimizations and enhanced error handling in CI environments.

  97. Ruby Core Updates: Test Stability and Documentation Improvements

    Ruby Core merged 13 pull requests focused on improving test reliability and fixing documentation issues. Notable changes include Ractor concurrency improvements and timeout adjustments for flaky tests.

  98. Ruby Core Updates: ZJIT Performance Enhancements and GC Improvements

    The Ruby core team merged 10 pull requests focused primarily on ZJIT compiler optimizations, with significant improvements to polymorphic method dispatch and super call handling. Additional work included garbage collection verification…

  99. Segfault Fix and Performance Improvements

    Ruby core developers merged a critical segfault fix for method forwarding with splat operators and implemented Prism performance optimizations. Additional maintenance included compiler warning fixes and documentation updates.

  100. ZJIT Performance and Documentation Updates

    Ruby core received 10 merged pull requests focusing heavily on ZJIT compiler improvements, including partial SSI cleanup, statistics fixes, and alias resolution. Additional changes include type validation for ObjectSpace and…