Recap Rails World & EuRuKo 2025

Hotwire Native & Offline Mode

A focus of Rails World was on the further development of Hotwire Native Apps. With Rails 8.1, these will support offline functionality for the first time. This allows users to use services even when the connection is lost. An important step to make Rails even more attractive in the development of mobile applications. Rosa Gutiérrez outlined the challenging path to enable these functionalities, and Joe Masilotti explained the practical implementation of native apps in combination with Rails applications.

Resumable Jobs

Another highlight were the resumable jobs. introduced with Rails 8.1Background tasks that used to run for hours can now be paused and resumed in the future. This makes the operation significantly more stable - for example, in deployments that are no longer blocked by long jobs. Donal McBreen provided an insight into the functionality that will be introduced in Rails 8.1 in his presentation. 

Performance & Stability

Another focus of Rails World was optimization directly on and with Ruby on Rails. Austin Story shed light on a real-life practical example of how applications can be built with Rails that are confronted with extremely high data throughput.
In this specific case, not only could the performance of an existing application landscape be improved, but costs could also be reduced.

Aaron Petterson, also a ruby core maintainer, showed how the current development of the Ruby language is progressing. He explained, among other things, how Ractor works. A new way in which parallelization can be achieved in Ruby. He described in great technical depth the differences between the existing parallelization options and Ractor. However, Ractor is currently considered an experimental feature.

Rails applications are ready for the AI revolution

Paweł Strzałkowski started his AI talk with a look back at the beginnings of Rails. He described the feeling of how fast and easy it was to build web applications with RoR.

He showed how easy it is in Rails to write applications using the Model Context Protocols (MCP) that allow AI models or agents to communicate and act.

Opening Keynote by Matz

Yukihiro "Matz" Matsumoto opened the conference with a very personal talk about the joy of programming and the future of Ruby. His idea that Ruby could become more important in the context of AI was intriguing, thanks to its clear syntax that is also easily readable for machines. At the same time, he emphasized that AI does not yet produce truly robust code; its greatest benefit currently lies in assisting functions such as refactoring or documentation.

Roasting Code with AI

The presentation by Obie Fernandez was particularly impressive. Shopify presented with Roast Introducing a framework for structured AI workflows that enables deterministic processes. Instead of unpredictable prompts, reusable processes can be defined, which can be used for tasks such as code reviews, log analysis, or data pipelines. An exciting glimpse into how AI can be used more predictably and productively in the Ruby environment.

ReActionView

With ReActionView, Marco Roth introduced a new ERB engine. ERB is a template format that allows embedding Ruby code directly into HTML. The new engine brings improved tooling, syntax tree support, and debugging features, making it possible to integrate modern frontends more strongly into the Rails stack. Together with Hotwire, ERB could regain attractiveness for complex UIs.

Further Sessions

Apart from the main lectures, there was a lot of input:

• How to integrate language models with RubyLLM: The library provides a unified interface and makes it easier to switch between different models.

• In the talk "Prioritizing Justice", the focus was on considering waiting times per customer instead of just per job in order to solve bottlenecks more fairly.

• In workshops and lightning talks, the topics ranged from AI-supported tests to new Ruby libraries and community initiatives such as Rubycademy.

Closing Keynote by Eileen Uchitelle

The conclusion was the keynote by Eileen Uchitelle. She showed that the common problems of large applications - messy codebases, fragile tests, complex deployments - cannot be solved solely by splitting into modules or microservices. On the contrary: Early modularization can do more harm than help.
Many challenges are less of a technical nature, but rather related to organization and collaboration: When it is unclear who is responsible for certain parts of an application, when technical debts accumulate over years, or when new features are prioritized over quality under time pressure - then no matter how sophisticated the architecture is, these problems cannot be solved. Instead, what is needed is a clear focus on clean code, regular maintenance of existing systems, and continuous training of the teams.