Closing Keynote at Rails World 2025

Aaron Patterson, a longstanding Ruby and Rails core team member and Senior Staff Engineer at Shopify, delivered the closing keynote at Rails World 2025. The primary focus was on innovations Shopify’s Ruby & Rails Infrastructure team is contributing to Ruby core, specifically around enabling better parallelism (via Ractors) and introducing a new method-based JIT compiler (ZJIT). Patterson also shared actionable advice for Rails developers on optimizing their code for JIT performance and parallelism.

Main Theme

The main topic addressed was improving Ruby’s concurrency, parallelism, and runtime performance, making Ruby and Rails applications faster and more scalable for production use cases.

Key Points

• Shopify’s Infrastructure Work:

  • The team’s goal is to improve machine utilization and throughput without increasing application latency.
  • Challenges with serving a mix of IO-bound and CPU-bound requests on multicore machines and Ruby’s historical process-based parallelism limitations were discussed.

• Parallelism and Web Servers:

  • Demonstrated limits of Ruby threads and fibers for CPU-bound work, noting that only processes (and now Ractors) provide true CPU parallelism.
  • Described theoretical model for a load-aware web server using HTTP/2 for back pressure.

• Ractors in Ruby 3.5:

  • Patterson explained Ractors as Ruby’s actor-style concurrency solution, providing true parallelism by assigning each Ractor its own GVL (Global VM Lock).
  • Emphasized current experimental status but shared ongoing efforts to stabilize and improve them in Ruby 3.5.
  • Provided examples on using Ractors, rules for passing immutable data, and communication via ports.
  • Noted design trade-offs: Ractors are harder to use than threads but eliminate common issues like mutexes and deadlocks.
  • Illustrated a production bottleneck (JSON parsing contention) and how Shopify’s team removed global lock contention, significantly speeding up parallel JSON parsing.

• JIT Compilers: YJIT and ZJIT:

  • Explained what JIT compilers are and how they can improve performance by removing interpreter overhead, caching values, speculating on types, and eliminating type checks.
  • Compared YJIT (lazy basic block versioning) with the new ZJIT (method-based JIT). YJIT compiles code on-demand and is efficient for warm-up and memory usage, but ZJIT can produce better register allocation and performance in some cases.
  • ZJIT is new and experimental but aims to build on YJIT’s foundations.

• Pro Tips for Rails Developers:

  • Advised on writing JIT-friendly, performance-oriented code:
  • Monomorphize call sites (use consistent types to help the compiler).
  • Set instance variables in a consistent order.
  • Avoid unnecessary, low-value polymorphism.
  • Real-world examples demonstrated how small adjustments can produce double-digit performance gains, even without a JIT.

Conclusions & Takeaways

• Ruby 3.5 will introduce both faster object allocations and substantial improvements to parallelism and JIT compilation.
• Developers are encouraged to experiment with Ractors and wrap CPU-intensive work in Ractors to utilize all CPU cores efficiently.
• Upgrading to Ruby 3.5 is recommended to achieve these performance benefits in Rails apps.

Relevant Examples & Anecdotes

• Demonstrated benchmarks for request handling, Fibonacci calculations using threads/fibers/ractors, and effect of Ractor improvements on JSON parsing.
• Discussed real-world issues Shopify’s team faced and resolved in Ruby internals related to global shared tables.
• Used relatable programming sketches, jokes, and compiler metaphors to explain complex concepts accessibly.

Audience

This talk targets Ruby and Rails developers interested in concurrency, application optimization, and upcoming Ruby core features.