by The History and Evolution of Ruby on Rails
In 2004, David Heinemeier Hansson extracted a web framework from his Basecamp application and gifted it to the world as open source. Thus, Ruby on Rails was born—a revolutionary approach to web development, based on solid principles like "Convention over Configuration" (CoC) and "Don’t Repeat Yourself" (DRY).
In its early years, Rails attracted an active community that helped drive small startups and major tech companies through the framework. Its proposal to abstract repetitive complexities and provide a simple, coherent structure for full-stack development quickly made it one of the most influential technologies in the web ecosystem.
Throughout its history, each version reflected the emerging needs of the community, incorporating modern patterns, facilitating scalability, and embracing new web development practices. This journey is marked by technical milestones, controversies, and achievements, all supported by a community that helped shape the project’s future with every pull request, gem, and release.
In this post, we’ll revisit the main milestones of this trajectory, contextualizing some of them, exploring how the framework matured, and discussing what’s still happening today.
Timeline
Before we dive into each topic, here’s a timeline with the main technical milestones in the framework’s evolution. If you prefer to jump to a specific milestone, click the indicated link to scroll to the desired section.
2011 – Rails 3.1
Release Notes 3.1- Introduction of the Asset Pipeline, based on Sprockets. This allowed concatenation, minification, and the use of preprocessors (Sass, CoffeeScript) for CSS and JavaScript files.
2013 – Rails 4.0
Release Notes 4.0- Launch of Turbolinks, providing smoother navigation by updating only the page via AJAX in a more efficient way.
2014 – Rails 4.2
Release Notes 4.2- Creation of Active Job, a unified abstraction for background job queues.
2016 – Rails 5.0
Release Notes 5.0- Introduction of ActionCable, native WebSockets support for real-time applications.
- Launch of Rails API mode, making it easier to create lightweight, decoupled RESTful backends.
2017 – Rails 5.1
Release Notes 5.1- Native integration with Yarn and Webpacker, bringing Rails into the modern JavaScript ecosystem.
2019 – Rails 6.0
Release Notes 6.0- Introduction of Action Mailbox, allowing receiving and processing emails within Rails applications.
- Launch of Action Text, a complete solution for rich text editing, including Trix support and file storage.
2021 – Rails 7.0
Release Notes 7.0- Hotwire (Stimulus + Turbo) integrated by default into the framework.
- Use of Import Maps as an alternative to Webpacker and Node.js dependency.
2024 – Rails 8.0
Release Notes 8.0- Introduction of Solid Cache and Solid Queue, native alternatives for caching and job queues, eliminating dependencies like Redis.
- Introduction of Propshaft, a brand new asset pipeline, fully restructured, focused on simplicity and performance.
Milestones
Based on the milestones presented in the timeline, let’s dive deeper into what each update brought. It’s also important to mention that these updates are key points that reflect the framework’s ability to evolve without compromising its foundational principles.
2011 – Rails 3.1: The Birth of the Asset Pipeline
- Year/Version: 2011, Rails 3.1.
- What changed: Rails 3.1 introduced the Asset Pipeline. This feature is based on Sprockets.
In 2011, the web development world was changing rapidly. JavaScript was no longer just an optional script at the end of pages, but the core of modern applications. CSS files were evolving with language preprocessors like Sass, and Rails’ answer to these changes came with the Asset Pipeline, built on top of Sprockets.
Before Rails 3.1, CSS and JavaScript files were served statically. With Rails 3.1, for the first time in Rails history, CSS and JavaScript files were not just served statically—they were orchestrated, concatenated, minified, and optimized automatically. The goal was to make it easier to include files from modern libraries and engines without complex manual configurations.
Automating the bundling of static assets resulted in significant improvements in caching and page load times. At a time when configuring a front-end build system required deep knowledge of complex tools, Rails, true to its philosophy, said: “Don’t worry about it. We’ll take care of it for you.”
2013 – Rails 4.0: Accelerated Navigation with Turbolinks
- Year/Version: 2013, Rails 4.0.
- What changed: Rails 4.0 included Turbolinks. It became a default dependency of the framework.
Two years later, a new obsession took over web development: performance. Users no longer tolerate slow pages. SPAs (Single Page Applications) were gaining popularity but required complex JavaScript knowledge.
So, not to be left behind, Rails introduced Turbolinks, and the main motivation for including this feature in the framework was to speed up navigation between pages of an application. It works by intercepting link clicks and using AJAX together with the browser’s pushState API. Instead of reloading the entire page, Turbolinks loads only the necessary part of the HTML.
On the first request, it delivers a full HTML page, but on subsequent navigations, it updates only the content and the page
For the user, the experience was almost instant navigation. The perception of performance improved drastically. With this notable gain in perceived performance, however, the introduction of Turbolinks required adjustments to existing front-end scripts, such as migrating from jQuery-UJS, due to partial DOM reloads.
Despite some criticism and the need for additional configuration in certain scenarios, Turbolinks was an important precursor to what would become Hotwire. The idea of "HTML-over-the-wire," where the server remains responsible for rendering HTML but delivers it more intelligently and efficiently.
2014 – Rails 4.2: The Era of Background Jobs
- Year/Version: 2014, Rails 4.2.
- What changed: The Active Job framework was added to Rails. Active Job was included directly in the core of the framework.
As Rails applications became more robust, the need to execute tasks asynchronously—such as sending emails, processing images, or generating reports—became essential to avoid blocking the user experience. These "background jobs" were crucial for performance and scalability, but their implementation could vary a lot depending on the chosen queue solution, like Sidekiq, Resque, or others.
To address this, Rails introduced Active Job with a focus on unification. The concept provided a simple abstraction layer, allowing developers to write jobs generically, without coupling to a specific queue backend. Switching from Sidekiq to Resque, for example, would no longer require rewriting all job logic.
The impact of this feature was the simplification and standardization of asynchronous processing in Rails. Tasks like sending emails became trivially asynchronous with the deliver_later method from Action Mailer.
Active Job also integrated GlobalID, making it easier to pass Active Record objects to jobs.
This standardization not only made code cleaner but also encouraged broader use of background jobs, making Rails applications more scalable in a simple way.
Since Active Job was included in the framework core, any Rails application now had a standardized infrastructure for queuing and processing jobs.
2016 – Rails 5.0: Real-Time Web and Modern APIs
- Year/Version: 2016, Rails 5.0.
- What changed: Rails 5.0 marked a turning point by introducing ActionCable and Rails API mode.
Rails 5.0 brought two major innovations that expanded the framework’s reach: native support for real-time web applications and an easier way to create modern, lightweight APIs.
ActionCable was Rails’ answer to the growing demand for interactive web applications, such as chats, instant notifications, and real-time dashboards. Before ActionCable, implementing WebSockets in Rails required external solutions or a lot of manual configuration. With ActionCable, WebSockets support became integrated into the framework core, allowing developers to create bidirectional communication channels between client and server simply and idiomatically, leveraging all of Rails’ infrastructure (routes, authentication, ActiveRecord, etc.). This paved the way for much more dynamic user experiences, without relying on polling or external libraries.
Rails API mode emerged to address another strong trend: decoupled application architectures, where the backend serves only as an API. The new mode allowed developers to generate minimalist Rails applications, without unnecessary views or helpers, focused solely on delivering JSON. This reduced memory usage, improved performance, and simplified the development of modern backends, making Rails a competitive choice for pure API projects.
2017 – Rails 5.1: Embracing the JavaScript World
- Year/Version: 2017, Rails 5.1.
- What changed: Rails 5.1 brought integrated support for the modern JavaScript ecosystem, including Yarn and Webpack, implemented through the Webpacker gem.
By 2017, the JavaScript world had exploded. React, Vue, Angular—frameworks promising rich, interactive UIs. Node.js was conquering both front-end and back-end. So Rails 5.1 welcomed Webpack and Yarn into its ecosystem via the Webpacker gem, which became essential for any serious project.
Rails started supporting Yarn and Webpack natively, which was optional and enabled with the rails new --webpack command, allowing Rails developers to use the vast npm ecosystem and build modern UIs with React or Vue while keeping the backend in Rails.
The Webpacker gem integrated Webpack, a popular JavaScript module bundler, enabling the use of newer syntax (like ES6 modules) and organizing JavaScript code into packages. Initially, the Asset Pipeline (Sprockets) was still maintained for managing CSS and HTML.
This integration opened the door to building rich and complex user interfaces within Rails. Although Webpack configuration added a new layer of complexity—and sparked debates in the community—it was a crucial step.
In Rails 6.0, Webpacker became the default for JavaScript assets, signaling the framework’s commitment to staying up to date with front-end best practices, even if it meant embracing tools outside its core.
2019 – Rails 6.0: Action Mailbox and Action Text
- Year/Version: 2019, Rails 6.0.
- What changed: Rails 6.0 also brought two major innovations for modern application development: Action Mailbox and Action Text.
Action Mailbox was created to make it easier to receive and process emails directly within a Rails application. With it, it became possible to turn incoming emails into Active Record objects, enabling workflows like creating comments, support tickets, or processing attachments from messages sent to specific addresses. Action Mailbox supports popular providers like Amazon SES, Mailgun, Mandrill, Postmark, and even direct input via SMTP or local files, making Rails even more complete for applications that rely on email communication.
Action Text brought an integrated solution for rich text editing in Rails applications, using the Trix editor. With Action Text, it became simple to add formatted text fields, images, links, and attachments, all managed transparently by the framework. File storage is handled via Active Storage, ensuring native integration with cloud or local storage services.
Rails 6 also consolidated other improvements, such as the exclusive use of Zeitwerk for class loading and enhancements in ActiveRecord (multi-database support, encryption, etc.).
2021 – Rails 7.0: Transition to Hotwire and Import Maps
- Year/Version: 2021, Rails 7.0.
- What’s changed: Hotwire has become the default strategy for front-end interactivity. Import Maps became the default for JavaScript dependency management, removing the need for Webpack or Sprockets by default. Both Webpacker and Sprockets became optional and are no longer included in new applications unless explicitly added.
Three years later, a collective reflection emerged in the community. Webpack was powerful but complicated. Build steps were useful but frustrating. Node.js was popular, but adding an entire language to the stack for a few libraries felt excessive.
The response was revolutionary: Hotwire and Import Maps. In pursuit of simplicity, Hotwire — a combination of Turbo and Stimulus — enabled dynamic, interactive user experiences with minimal custom JavaScript. At the same time, Import Maps allowed developers to use JavaScript modules directly in the browser without requiring bundlers like Webpack, effectively eliminating the need for a build step in many cases. The result was a return to Rails’ roots: server-driven logic, direct HTML rendering, improved performance, and a streamlined developer experience.
Hotwire (HTML-over-the-wire) proposes building reactive applications by sending partial HTML from the server, as previously mentioned, and Stimulus is a small JS framework for managing controllers/actions in HTML (existing since ~2017), while Turbo (successor of Turbolinks) expands the concept of fast navigation with Turbo Drive , Frames , and Streams . Turbo accelerates links/forms by transforming them into asynchronous requests by default and allows updating fragments of the page through server responses or ActionCable (Streams).
The impact of Rails 7.0 was profound. It offered a path to building rich, interactive web applications with a simplicity reminiscent of early Rails, but with the power of modern technologies. The convention of using Turbo/Stimulus influenced the community to write less custom JavaScript and focus on the server flow, reclaiming some of Rails’ original simplicity with high responsiveness.
By adopting Import Maps as the default for JavaScript management, Import Maps enables the use of modern JavaScript modules directly in the browser, without the need for bundling or transpiling. For many applications, this meant the end of the dependency on Node.js and complex JavaScript toolchains, potentially avoiding bundlers altogether and simplifying deployment.
2024 – Rails 8.0: The Future with Rails 8.0
You can check the list of Rails 8 milestones on GitHub.
The next chapter in the story promises to get rid of dependencies like Redis, incorporating Solid Cache and Solid Queue into the core. A new, native, and integrated asset pipeline emerges as a key piece to reduce complexity: Propshaft. All of this delivers an even cleaner Rails, ready to keep surprising developers. Improvements in support for Progressive Web Apps (PWAs) and push notifications are also on the radar, such as Action Notifier.
Along with these releases, there are several other topics that deserve their own blog post, including:
Kamal: Simplified and Modern Deployment
Rails 8.0 adopts Kamal as the official deployment solution. Kamal is an agnostic, container-based deployment tool that makes it easy to publish Rails applications on any infrastructure (cloud, VPS, bare metal), without relying on proprietary services. It automates provisioning, updates, and rollbacks, making deployment as simple as a single command, aligned with the "rails new, rails deploy" philosophy. This drastically lowers the barrier to putting Rails apps into production, especially for small teams or solo developers.
LSP: Enhanced Development Experience
Native support for the Language Server Protocol (LSP) arrives in Rails 8.0, elevating the development experience in modern editors like VS Code, RubyMine, and others. With LSP, features like autocomplete, file navigation, real-time error detection, and refactoring become smarter and more integrated into Rails’ ecosystem, making development more fluid and productive.
Rubocop + Brakeman: Security and Quality by Default
Starting with Rails 8.0, tools like Rubocop (Ruby code linter and formatter) and Brakeman (vulnerability scanner for Rails apps) are included by default in new projects. This encourages the adoption of best coding and security practices from the start, helping to avoid common problems and known vulnerabilities, and making it easier to maintain healthy codebases.
Other highlights
- Propshaft: replaces Sprockets as the asset pipeline, focusing on simplicity, performance, and native integration with the framework.
- Solid Cache and Solid Queue: eliminate the need for Redis for cache and queues, making setup leaner and easier to maintain.
- Action Notifier: new framework for push notifications, making it easier to create PWAs and modern browser experiences.
With all these new features, Rails 8.0 reinforces its position as the most productive and accessible web framework on the market, ready to serve both solo projects and large global platforms. In addition, these changes are expected to continue the trend of simplifying the infrastructure needed to run modern Rails apps, reducing the need to configure and manage additional services. This should make Rails even more "ready to use" and simplify deployment for many scenarios.
A Tradition of Innovation
Ruby on Rails’ trajectory is a testament to its resilience and adaptability. From simplifying asset management to revolutionizing front-end interactivity, each milestone in its history has been driven by a desire to improve developer productivity and user experience.
Along the way, there has been much criticism and debate, especially regarding scalability, and given the demands of the technologies, there have been improvements to the framework’s core, optimizations to the ORM model, Active Record, a greater push for good architectural practices, as well as adequate infrastructure, so that several benchmarks show Rails handling thousands of requests per minute with ease – companies like Github and Shopify are living proof that Rails scales a lot with the right engineering behind it.
From the introduction of Asset Pipeline for managing static resources to the navigation traction with Turbolinks, the standardization of background jobs with Active Job, the attempt to embrace the modern JS ecosystem with Webpacker, to the recent and significant transition to Hotwire and Import Maps, the framework has evolved consistently. Rails today is not the same framework it was in 2004, but it carries the same soul: the promise that web development can be productive and is known today as the one-person framework. As DHH quotes in his post One Person Framework
The part that really excites me about this release, though, is how much closer it brings us to the idea of the One Person Framework. A toolkit so powerful that it allows a single individual to create modern applications on which to build a competitive business. The way it used to be.
And this story continues to be written, one compromise at a time, one convention at a time, one developer joy at a time.
While web technology continues to bring new and relentless demands day after day, Rails has shown, version after version, that it is ready to respond to the demands of technology and adapt to lead, innovate, and above all, continue to be strongly recommended as a framework for modern web applications.
If you liked this post, be sure to follow our blog! And if you would like to remember another milestone in the history of Rails, leave your comment below, it will be very welcomed!
Appendix of Terms
Considering that not all readers may be familiar with the terms or technologies mentioned in the blog post, we have created this glossary in alphabetical order:
- Action Cable: Added in Rails 5.0 (2016), it provides integrated support for WebSockets, enabling real-time features such as chats and notifications. Rails 8 plans a database-based adapter.
- Action Notifier: Introduced in Rails 8 to manage push notifications and facilitate the creation of PWAs.
- Active Job: Introduced in Rails 4.2 (2014), it is an abstraction layer for background job queues, allowing integration with various backends (Sidekiq, Resque, etc.).
- Active Record: Rails’ standard ORM (Object-Relational Mapping). It allows you to interact with the database using Ruby, facilitating CRUD operations, associations, validations and migrations.
- Ajax: A technique for making web applications more interactive without reloading the entire page. Turbolinks (Rails 4.0) used Ajax with pushState for fast navigation.
- Asset Pipeline: Introduced in Rails 3.1 (2011), it automates concatenation, minification, and preprocessing of static files (CSS, JS), improving caching and performance.
- Brakeman: Security vulnerability scanner for Rails applications, included by default in Rails 8.
- CoC (Convention over Configuration): A design principle popularized by Rails that prioritizes sensible conventions to reduce manual configuration and speed up development.
- CoffeeScript: A preprocessing language that compiles to JavaScript, supported by Asset Pipeline.
- DRY (Don’t Repeat Yourself): Principle that encourages avoiding code repetition, promoted in Rails by Partials, Helpers, Concerns and Active Record.
- GlobalID: Technology used by Active Job to serialize database objects into jobs.
- Hotwire: Standard front-end approach in Rails 7 (2021), based on "HTML-over-the-wire". Combines Turbo and Stimulus to create interactivity with minimal custom JavaScript.
- Import Maps: Introduced in Rails 7, it allows you to use JavaScript modules directly in the browser without bundlers, simplifying configuration and deployment.
- Kamal: Container-agnostic deployment tool, official deployment solution for Rails 8.
- LSP (Language Server Protocol): Protocol that allows editors/IDEs to communicate with language servers for features like auto-completion and linting. Rails 8 will have native support.
- MVC (Model-View-Controller): Architectural pattern that separates the application into Model, View and Controller, facilitating code organization and maintenance.
- Node.js/Yarn: Node.js is a server-side JavaScript runtime; Yarn is a package manager. Both have been integrated into Rails 5.1 to make it easier to use the modern JS ecosystem.
- Propshaft: New asset pipeline in Rails 8, focused on simplicity and performance, replacing Sprockets.
- PWA (Progressive Web App): Web application that offers a native app-like experience, with offline support, push notifications, etc. Rails 8 improves support for PWAs.
- Redis: In-memory storage system traditionally used for caching and queuing. Rails 8 brings native alternatives (Solid Cache and Solid Queue) to reduce the dependency on Redis.
- Resque: Queue backend for background jobs, supported by Active Job.
- Rubocop: Ruby code linter and formatter, included by default in Rails 8.
- Sass: CSS preprocessing language, supported by Asset Pipeline.
- Sidekiq: Popular backend for background job processing, supported by Active Job.
- Solid Cache and Solid Queue: Native database-based caching and work queue components, standard in Rails 8.
- SPA (Single-Page Application): Web application that loads a single HTML page and dynamically updates the content, providing a fluid experience.
- Sprockets: Core technology of Asset Pipeline in Rails 3.1, standardized the front-end workflow.
- Stimulus: Small JavaScript framework, part of Hotwire, to manage controllers and actions in HTML.
- Turbo: Successor to Turbolinks, part of Hotwire, expands fast navigation and page fragment updates via Turbo Drive, Frames and Streams.
- Turbolinks: Library introduced in Rails 4.0 to speed up navigation, loading only part of the HTML via Ajax and pushState.
- Webpacker: Gem that integrated Webpack into Rails (from 5.1), allowing the use of modern JavaScript and frameworks like React and Vue.
- Zeitwerk: Rails-only class loader from version 6 onwards, consolidated in Rails 7, that automates the loading of Ruby files.
References
The Asset Pipeline via Rails Guides
Here’s what’s coming in Rails 8, Harrison Broadbent via RailsNotes
Rails 8.0: No PaaS Required, David Heinemeier Hansson, via Ruby on Rails
The History of the Asset Pipeline, Ariel Juodziukynas via FastRuby.io
The Plan for Rails 8, Brad Gessler via RubyDispatch
Shopify and Open Source: A Mutually Beneficial Relationship – Shopify
We want to work with you. Check out our "What We Do" section!
