RubyKaigi is my favourite Ruby conference. I appreciate everyone putting on Ruby conferences all over the world. I've enjoyed every conference I've attended. RubyKaigi is just the one that’s most suited to my tastes.

RubyKaigi combines the opportunity to see more of Japan each year with extremely technical content. The caliber of speakers and the detail that they pack into their talks is unparalleled. This kind of content isn't everyone's jam, but it's definitely mine.

Despite not working on Ruby itself, I find the work that people do on the language fascinating. Work done by folks all over the world to improve Ruby makes my apps faster, more secure, and more maintainable.

RubyKaigi sees the folks that do that work coming together from all over the world in a single place. It's a unique focal point for the Ruby world, and it moves to a new part of Japan each year. My hope is to attend every year if I'm able. (This year makes two in a row, and since next year’s location has surfing, you can assume I’ll be there.)

If you’re curious about what attending RubyKaigi is like, or just looking for a preview of what talks to check out once the videos are up, here’s a brief review of the talks I attended. (Keep in mind there were three different tracks, so this is only a fraction of the talks.)

Day 1

The opening keynote explored Satoshi Tagomori’s experience working on Ruby’s new isolated namespace feature, Boxes. The talk dove into the technical details of implementing boxes at the virtual machine level, how to use them, and how you can debug them. It was a perfect way to start the conference in Hakodate. (Hakodate translates literally to “box building”.)

My second session of the day was title “Back to the roots of date”. The talk focused on an AI-enabled attempt to reimplement the Date class in pure Ruby. I don’t find talks that focus on how the presenter used LLMs to be interesting. I want to hear about the work itself.

My next session was more fun; it explored the effort to make test/unit into a parallel test runner. Much of the complexity was due to the need to support Windows (unfortunate but fair), but it was still interesting to hear about. Currently only process-based parallelism is supported, but they want to add Ractor-based parallelism later.

The folks who work on profilers always seem to attend RubyKaigi. John Hawthorn, Ivo Anjo, and Daisuke Aritomo were all presenting this year. Daisuke Aritomo was presenting on CPU profiling, which is more relevant than ever with the improvements to Ractors.

After that talk, I headed to Luke Gruber’s presentation. He reviewed the state of Ruby’s thread scheduler, how the round robin algorithm and 100ms quantum leads to a simple, high throughput, low responsiveness scheduler. After discussing what languages like Go and Python have done to improve their schedulers, he laid out his suggestion: a multi-level feedback queue. He hopes that the community can focus more on the scheduler and add more multi-threaded benchmarks to ruby-bench.

I then hit up Yuichiro Kaneko’s talk on Lrama. There are always folks who are enthusiastic about Lrama and RubyKaigi. I don’t share their enthusiasm. Prism exists to unify the community under one parser implementation. I don’t really know why we’re still talking about this. (It was an interesting talk, though.)

The second to last talk of the day was from Max Bernstein. He laid out the state of ZJIT and their plans for the next 5 years. It was a big picture talk (there were many other much more focused ZJIT talks on later days), and the main takeaway is that they are aiming for 5x speedup. ZJIT already outperforms YJIT on some microbenchmarks, but it’s still overall slower.

Day 2

I might have missed the first couple of sessions on day two. This might be related to partying the night before.

My first session of the day was Peter Zhu’s talk on garbage collectors. He outlined the work that’s been done with MMTk to support additional garbage collection algorithms, their performance, and what’s next for garbage collection in Ruby.

Next up was a great talk on Shopify’s move to the Falcon web server. Falcon uses a fiber scheduler to serve multiple requests concurrently per process. There were a number of snags, but Shopify was ultimately able to switch to Falcon ahead of BFCM and saw some real performance gains. I’m curious if our apps could switch.

One of the special treats you get at RubyKaigi is Aaron Patterson presenting in Japanese, this year on a new approach to FFI that he calls FFX. Essentially, FFX is a transpiler that generates C extensions from FFI bindings, but adds JIT hints, making the resulting extensions faster than normal native C extensions. You can check the project out here.

Before the afternoon break, Jeremy Evans dove into the improvements that were done when the Set class was upgraded from the standard library to a core class. Set used to be backed by a hash, but this caused it to use about 50% more memory than necessary. Jeremy walked through the nitty gritty of the new implementation.

Next up, Maciej Mensfeld provided an overview of an approach he was using in his projects to leverage Ractors to speed up CPU-bound workloads.

We then heard from Yusuke Endoh (aka Mame) on applying TypeProf to Optcarrot, an NES emulator that serves as a Ruby benchmark. TypeProf is much less strict than something like Sorbet, but it’s still a neat tool for detecting type errors in Ruby programs. He was able to get Optcarrot passing type validation with only minor changes.

The final session of the day was from Stan Lo. He talked about all the awesome work he’s done to improve Ruby’s documentation. He also discussed the future improvements he wants to make to the documentation and to RDoc itself.

Day 3

The third day started with “Ruby Committers and the World”, a discussion between all the attending Ruby committers on a variety of topics. There were technical topics (can we remove setjmp/longjmp?), but there was also an extended discussion on AI that I could do without. I use LLMs, but I also agreed with Jean Boussier when he said that using AI removes the fun of working with Ruby. Anyway, the committers don’t seem to have a consensus on flipping the switch on frozen string literals. Maybe next year.

Speaking of LLMs, Nate Berkopec talked about using autoresearch to improve the performance of Ruby applications. There was a lot of speculation in the talk, but I agree with him on one point: you shouldn’t be generating PRs with LLMs that you’re not capable of properly reviewing yourself.

John Hawthorn was up next. He wrote a garbage collector for Ruby that detects write barrier bugs and confirms when they are fixed. His hope is that it can be added to Ruby’s CI to make developing Ruby easier and safer. It’s very cool.

Ivo Anjo gave a ton of tips for writing C extensions. This talk was quite technical, but contained so much great advice for anyone writing C extensions.

Marco, on a another extended conference tour, showed us the latest and greatest from Herb. There’s some very cool stuff in there. Beyond his goals of fully reactive frontend for Rails, he showed off Herb::Engine, an Erubi::Engine-compatible template rendering engine that validates your HTML, gives you better error messages, includes crazy in-browser development tooling, and even supports HTML-diffing when you change your templates and pushing the changes to the browser without a page reload in development. Cool shit.

Next was one that I was excited for: Alexandre Terrasa showing off Rubydex, the next generation of source code indexers for Ruby. Like Prism, this is an effort to unify tools like Ruby LSP, Spoom, and Tapioca to use a single indexer. Besides eliminating the need for each project to maintain its own indexer, Rubydex is also super fast. It provides Ruby, C and Rust APIs and is available to try now. I kinda want to build something with it.

One talk to go before Matz’s closing keynote: Takashi Kokubun talking about performance improvements to method calls in ZJIT. This was quite technical, showing the details of how frames are pushed and how the new system of “lightweight frames” works to reduce memory writes. I also liked Kokubun’s suggestion for how the Japanese should pronounce ZJIT. I blame Shopify (a Canadian company) naming something with a zed, but pronounced “zee”.

Matz closed the conference by showing us an RSS reader a Ruby AOT compiler called Spinel (not that Spinel) that he made with Claude Code. Spinel is self-hosted and available on GitHub already. I don’t really need a Ruby compiler, but I’m glad Matz is having fun building new things.

Next year’s conference will be in Miyazaki. Who wants to go surfing?

Since I'm in Japan, I haven't had the time to listen to any of this week's new releases. Also I'm a day ahead of most of the world, and I don't know how that affects things. Can I even listen to this week's new releases yet? I don't know.

Instead of a recommendation, I'm just going to share with you the new release I'm most excited for: At The Gates’ eighth studio album, The Ghost of a Future Dead. It is their final album featuring Tomas “Tompa” Lindberg, who passed away while the album was in production. Early reviews suggest the album is exceptional.