October 2025 - ruby-core - ml.ruby-lang.org

[ruby-core:116382] [Ruby master Feature#20205] Enable `frozen_string_literal` by default
by byroot (Jean Boussier) 28 Oct '25

28 Oct '25

Issue #20205 has been reported by byroot (Jean Boussier). ---------------------------------------- Feature #20205: Enable `frozen_string_literal` by default https://bugs.ruby-lang.org/issues/20205 * Author: byroot (Jean Boussier) * Status: Open * Priority: Normal ---------------------------------------- ### Context The `frozen_string_literal: true` pragma was introduced in Ruby 2.3, and as far as I'm aware the plan was initially to make it the default for Ruby 3.0, but this plan was abandoned because it would be too much of a breaking change without any real further notice. According to Matz, he still wishes to enable `frozen_string_literal` by default in the future, but a reasonable migration plan is required. The main issue is backward compatibility, flipping the switch immediately would break a lot of code, so there must be some deprecation period. The usual the path forward for this kind of change is to emit deprecation warnings one of multiple versions in advance. One example of that was the Ruby 2.7 keyword argument deprecation. It was quite verbose, and some users were initially annoyed, but I think the community pulled through it and I don't seem to hear much about it anymore. So for frozen string literals, the first step would be to start warning when a string that would be frozen in the future is mutated. ### Deprecation Warning Implementation I implemented a quick proof of concept with @etienne in https://github.com/Shopify/ruby/pull/549 In short: - Files with `# frozen_string_literal: true` or `# frozen_string_literal: false` don't change in behavior at all. - Files with no `# frozen_string_literal` comment are compiled to use `putchilledstring` opcode instead of regular `putstring`. - This opcode mark the string with a user flag, when these strings are mutated, a warning is issued. Currently the proof of concept issue the warning at the mutation location, which in some case can make locating where the string was allocated a bit hard. But it is possible to improve it so the message also include the location at which the literal string was allocated, and learning from the keyword argument warning experience, we can record which warnings were already issued to avoid spamming users with duplicated warnings. As currently implemented, there is almost no overhead. If we modify the implementation to record the literal location, we'd incur a small memory overhead for each literal string in a file without an explicit `frozen_string_literal` pragma. But I believe we could do it in a way that has no overhead if `Warning[:deprecated] = false`. ### Timeline The migration would happen in 3 steps, each step can potentially last multiple releases. e.g. `R0` could be `3.4`, `R1` be `3.7` and `R2` be `4.0`. I don't have a strong opinion on the pace. - Release `R0`: introduce the deprecation warning (only if deprecation warnings enabled). - Release `R1`: make the deprecation warning show up regardless of verbosity level. - Release `R2`: make string literals frozen by default. ### Impact Given that `rubocop` is quite popular in the community and it has enforced the usage of `# frozen_string_literal: true` for years now, I suspect a large part of the actively maintained codebases in the wild wouldn't see any warnings. And with recent versions of `minitest` enabling deprecation warnings by default (and [potentially RSpec too](https://github.com/rspec/rspec-core/issues/2867)) the few that didn't migrate will likely be made compatible quickly. The real problem of course are the less actively developed libraries and applications. For such cases, any codebase can remain compatible by setting `RUBYOPT="--disable=frozen_string_literal"`, and so even after `R2` release. The flag would never be removed any legacy codebase can continue upgrading Ruby without changing a single line of cod by just flipping this flag. ### Workflow for library maintainers As a library maintainer, fixing the deprecation warnings can be as simple as prepending `# frozen_string_literal: false` at the top of all their source files, and this will keep working forever. Alternatively they can of course make their code compatible with frozen string literals. Code that is frozen string literal compatible doesn't need to explicitly declare it. Only code that need it turned of need to do so. ### Workflow for application owners For application owners, the workflow is the same than for libraries. However if they depend on a gem that hasn't updated, or that they can't upgrade it, they can run their application with `RUBYOPT="--disable=frozen_string_literal"` and it will keep working forever. Any user running into an incompatibility issue can set `RUBYOPT="--disable=frozen_string_literal"` forever, even in `4.x`, the only thing changing is the default value. And any application for which all dependencies have been made fully frozen string literal compatible can set `RUBYOPT="--enable=frozen_string_literal"` and start immediately removing magic comment from their codebase. -- https://bugs.ruby-lang.org/

22 76

[ruby-core:123560] [Ruby Bug#21651] replacing a string with one backslash with two backslashes
by tdrive (Stanislav Boldaev) 28 Oct '25

28 Oct '25

Issue #21651 has been reported by tdrive (Stanislav Boldaev). ---------------------------------------- Bug #21651: replacing a string with one backslash with two backslashes https://bugs.ruby-lang.org/issues/21651 * Author: tdrive (Stanislav Boldaev) * Status: Open * ruby -v: 3.4.4 * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- ruby 2.7.8p225 (2023-03-30 revision 1f4d455848) [x86_64-linux] ruby 3.4.4 (2025-05-14 revision a38531fd3f) +PRISM [x86_64-linux] ``` irb(main):002> "\\".gsub("\\", "\\\\") => "\\" irb(main):003> "\\".gsub("\\", "\\ \\") => "\\ \\" ``` The replacement is happening, as you can see from the version with the space, but why is the result so strange without the space? Similar code works fine in JS: ``` "\\".replace("\\", "\\\\") > '\\\\' ``` How to replace one backslash with two backslashes? -- https://bugs.ruby-lang.org/

2 1

[ruby-core:123558] [Ruby Bug#21650] Performance regression: `Rational#floor(ndigits)` extremely slow for huge ndigits in Ruby 3.4 (ok in 3.2)
by koilanetroc (Oleg Tolmashov) 28 Oct '25

28 Oct '25

Issue #21650 has been reported by koilanetroc (Oleg Tolmashov). ---------------------------------------- Bug #21650: Performance regression: `Rational#floor(ndigits)` extremely slow for huge ndigits in Ruby 3.4 (ok in 3.2) https://bugs.ruby-lang.org/issues/21650 * Author: koilanetroc (Oleg Tolmashov) * Status: Open * ruby -v: ruby 3.4.7 (2025-10-08 revision 7a5688e2a2) +PRISM [arm64-darwin24] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- ## Summary `Rational#floor(ndigits)` with a very large positive ndigits takes tens of seconds in Ruby 3.4, while it returns essentially instantly in Ruby 3.2. Reproducible on macOS and Linux. Looks like a missing fast‑path for rationals whose decimal expansion terminates. ## Steps to reproduce ```ruby require "benchmark" puts RUBY_DESCRIPTION t = Benchmark.realtime { (2 ** -3).floor(2 ** 31) } puts "elapsed: #{t.round(3)}s" ``` Also reproduces with the explicit rational form: ```ruby Benchmark.realtime { Rational(1, 8).floor(2 ** 31) } ``` ### Results on my machine Ruby 3.2.8: ``` ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [arm64-darwin24] slow_math.rb:4: warning: in a**b, b may be too big elapsed: 0.0s ``` Ruby 3.4.7: ``` ruby 3.4.7 (2025-10-08 revision 7a5688e2a2) +PRISM [arm64-darwin24] elapsed: 39.214s ``` ## Actual behavior On Ruby 3.4.x this call takes ~tens of seconds (e.g., ~40s on my machine), consuming CPU. Same on macOS and Linux. ## Expected behavior The method should return quickly (ideally O(1)). -- https://bugs.ruby-lang.org/

2 4

[ruby-core:123506] [Ruby Misc#21646] Propose Luke Gruber as a Ruby committer
by jhawthorn (John Hawthorn) 28 Oct '25

28 Oct '25

Issue #21646 has been reported by jhawthorn (John Hawthorn). ---------------------------------------- Misc #21646: Propose Luke Gruber as a Ruby committer https://bugs.ruby-lang.org/issues/21646 * Author: jhawthorn (John Hawthorn) * Status: Open ---------------------------------------- I'd like to propose adding Luke Gruber (@luke-gru) as a Ruby committer. He's been contributing to CRuby since 2019 fixing a variety of bugs and being active on redmine both filing and fixing issues. For the past few years he's made a lot of improvements to help stabilize Ractors and we've been working together on this for the past several months. A small sample of his work (more from [@luke-gruber and @luke-gru on GitHub](https://github.com/search?q=repo%3Aruby%2Fruby%20is%3Apr%20author%3…) * Fixed a complex lock-ordering issue that caused Ractors to deadlock [ruby/ruby#13682](https://github.com/ruby/ruby/pull/13682) * Optimizing `Regexp#match` to avoid allocations [ruby/ruby#9398](https://github.com/ruby/ruby/pull/9398) * Fixed issues with moving objects to a Ractor [ruby/ruby#9394](https://github.com/ruby/ruby/pull/9394) [ruby/ruby#9996](https://github.com/ruby/ruby/pull/9996) * Fixed a GC+Ractor+tracing bug that crashed on CI [ruby/ruby#14596](https://github.com/ruby/ruby/pull/14596) * Fixed a bug where Mutexes locked by finished Fibers could segv [ruby/ruby#14262](https://github.com/ruby/ruby/pull/14262) * Fixed String#crypt inside Ractors [ruby/ruby#13567](https://github.com/ruby/ruby/pull/13567) It would be helpful to me and to Ruby if he had commit access to merge changes more easily. I would help with onboarding :) -- https://bugs.ruby-lang.org/

7 7

[ruby-core:123279] [Ruby Misc#21609] Propose Stan Lo (@st0012) as a core committer
by tekknolagi (Maxwell Bernstein) 28 Oct '25

28 Oct '25

Issue #21609 has been reported by tekknolagi (Maxwell Bernstein). ---------------------------------------- Misc #21609: Propose Stan Lo (@st0012) as a core committer https://bugs.ruby-lang.org/issues/21609 * Author: tekknolagi (Maxwell Bernstein) * Status: Open ---------------------------------------- ## Proposal I'd like to propose Stan Lo (@st0012) as a committer. He's been doing excellent work on ZJIT for the past couple of months, making sure we're compatible with the test suite, analyzing benchmark data, and optimizing the generated code. Especially since he has been contributing to Ruby for years now and knows the community, I think he should be able to merge his own changes. Here is Stan's message: ## Stan Lo's message I have been contributing to Ruby and core Ruby tools since 2021\. My main contributions have been: ### ZJIT Contributions ([60+ PRs](https://github.com/ruby/ruby/pulls?q=is%3Apr+author%3Ast0012+ZJIT+is%3…) - Made ZJIT work with TracePoint ([\#14407](https://github.com/ruby/ruby/pull/14407), [\#14420](https://github.com/ruby/ruby/pull/14420)) - Built infrastructure for annotating builtin functions ([\#14078](https://github.com/ruby/ruby/pull/14078)) - Implemented invalidation for method redefinition ([\#13875](https://github.com/ruby/ruby/pull/13875)), stable constants ([\#13998](https://github.com/ruby/ruby/pull/13998)), single Ractor mode ([\#14121](https://github.com/ruby/ruby/pull/14121)) - Supported compiling instructions: `concatstrings` ([\#14154](https://github.com/ruby/ruby/pull/14154)), `opt_and`/`opt_or` ([\#13830](https://github.com/ruby/ruby/pull/13830)), `invokeblock` ([\#14496](https://github.com/ruby/ruby/pull/14496)), `opt_case_dispatch` ([\#14433](https://github.com/ruby/ruby/pull/14433)) - Expanded test infrastructure to run against all Ruby tests ([\#13950](https://github.com/ruby/ruby/pull/13950)) ### Core Ruby Tools - **IRB** \- [All-time \#1 contributor](https://github.com/ruby/irb/graphs/contributors) and maintainer since 2022 - Implemented major features across Ruby 3.2-3.4: `cd` command, `edit` command, `show_cmds`, pager support, integration with `ruby/debug`…etc. - **RDoc** \- Maintainer since 2024 - Redesigned the default theme for Ruby 3.4+ ([\#1191](https://github.com/ruby/rdoc/pull/1191), [\#1157](https://github.com/ruby/rdoc/pull/1157)) - Created docs.ruby-lang.org with new homepage ([\#12227](https://github.com/ruby/ruby/pull/12227)) and greatly improved standard library page ([\#12404](https://github.com/ruby/ruby/pull/12404)) - **Debug** \- [\#2 contributor with 400+ commits](https://github.com/ruby/debug/graphs/contributors) - IRB integration ([\#1024](https://github.com/ruby/debug/pull/1024)) - `outline` command ([\#173](https://github.com/ruby/debug/pull/173)) - Backtrace filtering ([\#138](https://github.com/ruby/debug/pull/138)) I would like to continue contributing to ZJIT, IRB, RDoc, and other parts of Ruby. Being a committer would make it easier to maintain these critical tools and contribute to ZJIT's ongoing development. -- https://bugs.ruby-lang.org/

10 11

[ruby-core:123549] [Ruby Bug#21649] Ractors can access non-shareable object through singleton classes
by jhawthorn (John Hawthorn) 27 Oct '25

27 Oct '25

Issue #21649 has been reported by jhawthorn (John Hawthorn). ---------------------------------------- Bug #21649: Ractors can access non-shareable object through singleton classes https://bugs.ruby-lang.org/issues/21649 * Author: jhawthorn (John Hawthorn) * Status: Open * Assignee: ractor * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- If we send a non-shareable object into a Ractor, it needs to be copied. ``` ❯ ruby -W0 -e 'Ractor.new(p(Object.new)) { |o| p(o) }.join' #<Object:0x00000001240f8cf8> #<Object:0x00000001240f8870> ``` However we're able to instead smuggle it through a singleton class to unsafely get a mutable reference to the same object in both Ractors. ``` ❯ ruby -W0 -e 'Ractor.new(p(Object.new).singleton_class) { |o| p(o.attached_object) }.join' #<Object:0x0000000120768c40> #<Object:0x0000000120768c40> ``` I think we should probably make singleton classes copy the shareability of their attached object. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:123541] [Ruby Feature#15381] Let double splat call `to_h` implicitly
by sanjioh (Fabio Sangiovanni) 25 Oct '25

25 Oct '25

Issue #15381 has been updated by sanjioh (Fabio Sangiovanni). jeremyevans0 (Jeremy Evans) wrote in #note-11: > […] Maybe in Ruby 4? Bringing this up since it seems that this year’s Ruby version will be 4.0. Is this change going to be considered for inclusion in the new release? ---------------------------------------- Feature #15381: Let double splat call `to_h` implicitly https://bugs.ruby-lang.org/issues/15381#change-114919 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- The single splat calls `to_a` implicitly on the object (if it is not an array already) so that, for example, we have the convenience of writing conditions in an array literal: ```ruby a = [ *(:foo if some_condition), *(:bar if another_condition), ] ``` And the ampersand implicitly calls `to_proc` on the object (if it is not a proc already) so that we can substitute a block with an ampersand followed by a symbol: ```ruby some_method(&:some_method_name) ``` Unlike the single splat and ampersand, the double splat does not seem to implicitly call a corresponding method. I propose that the double splat should call `to_h` implicitly on the object if it not already a Hash so that we can, for example, write a condition in a hash literal as follows: ```ruby h = { **({a: 1} if some_condition), **({b: 2) if another_condition), } ``` There may be some other benefits of this feature that I have not noticed yet. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:122883] [Ruby Bug#21522] Accessing outer locals via eval in a Ractor returns false
by tenderlovemaking (Aaron Patterson) 24 Oct '25

24 Oct '25

Issue #21522 has been reported by tenderlovemaking (Aaron Patterson). ---------------------------------------- Bug #21522: Accessing outer locals via eval in a Ractor returns false https://bugs.ruby-lang.org/issues/21522 * Author: tenderlovemaking (Aaron Patterson) * Status: Open * Assignee: ractor * ruby -v: ruby 3.5.0dev (2025-07-28T22:17:45Z master f1acf47ca2) +PRISM [arm64-darwin24] * Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Normally, if you try to access a local that's been defined outside the scope of the Ractor block, it'll raise an ArgumentError. However, if you try to access the local via `eval` it will return the value `false`. ```ruby foo = Object.new begin Ractor.new { p foo }.value rescue ArgumentError end Ractor.new { p eval("foo") # => false }.value ``` I'm not sure how we fix this, since my guess is that we zero the environment when copying, but I wanted to file the issue so we can track it. -- https://bugs.ruby-lang.org/

2 1

[ruby-core:116083] [Ruby master Feature#20163] Introduce #bit_count method on Integer
by garrison (Garrison Jensen) 24 Oct '25

24 Oct '25

Issue #20163 has been reported by garrison (Garrison Jensen). ---------------------------------------- Feature #20163: Introduce #bit_count method on Integer https://bugs.ruby-lang.org/issues/20163 * Author: garrison (Garrison Jensen) * Status: Open * Priority: Normal ---------------------------------------- This feature request is to implement a method called #bit_count on Integer that returns the number of ones in the binary representation of the absolute value of the integer. ``` n = 19 n.bit_count #=> 3 (-n).bit_count #=> 3 ``` This is often useful when you use an integer as a bitmask and want to count how many bits are set. This would be equivalent to ``` n.to_s(2).count("1") ``` However, this can be outperformed by ``` def bit_count(n) count = 0 while n > 0 n &= n - 1 # Flip the least significant 1 bit to 0 count += 1 end count end ``` I think this would be a useful addition because it would fit alongside the other bit-related methods defined on integer: `#bit_length,` `#allbits?`, `#anybits?`, `#nobits?`. Also, when working with bitmasks, a minor upgrade to performance often results in a significant improvement. Similar methods from other languages: https://docs.python.org/3/library/stdtypes.html#int.bit_count https://doc.rust-lang.org/std/primitive.i32.html#method.count_ones -- https://bugs.ruby-lang.org/

13 24

[ruby-core:123241] [Ruby Feature#21572] Make illegal variable in alternation pattern a syntax error
by kddnewton (Kevin Newton) 23 Oct '25

23 Oct '25

Issue #21572 has been reported by kddnewton (Kevin Newton). ---------------------------------------- Feature #21572: Make illegal variable in alternation pattern a syntax error https://bugs.ruby-lang.org/issues/21572 * Author: kddnewton (Kevin Newton) * Status: Open ---------------------------------------- Currently when you have an illegal variable in an alternation pattern, you get a compile error, but no syntax error. ```ruby case foo in {a: } | Array "matched: #{a}" end ``` yields ``` $ ruby -cv test.rb ruby 3.5.0dev (2025-04-10T10:21:51Z master 756479324f) +PRISM [x86_64-linux] Syntax OK ``` but ``` $ ruby test.rb test.rb:2: illegal variable in alternative pattern (a) test.rb: compile error (SyntaxError) ``` Looking at the compiler, since illegal jumps (like break, next, etc.) are now syntax errors, the only other actual compiler errors are related to builtins. I think this should be a proper syntax error, so that editors and other tools can report on it and users can find it in development sooner. -- https://bugs.ruby-lang.org/

4 5