1995 – 2026
Ruby Versions
Every public release of Ruby — from Yukihiro “Matz” Matsumoto's first public release in 1995 through Ruby 4.0 in December 2025 — with ship dates, maintenance status, and the major changes per version. Plus the annual Christmas-day release tradition, the 2004 Rails moment that made Ruby a mainstream web language, the 1.9 / YARV break, Ractor parallelism, and the YJIT → ZJIT performance arc.
The 1993 origin and the Japanese years
Ruby was created by Yukihiro “Matz” Matsumoto in Japan. He settled on the name on February 24, 1993 — a deliberate gem-of-a-name follow-on to Perl — and began building a language that blended the parts he liked from Perl, Smalltalk, Lisp, and Ada into something “more powerful than Perl, and more object-oriented than Python.” His guiding principle was programmer happiness: Ruby is designed so that ordinary code reads naturally and the language gets out of your way.
The first public release — Ruby 0.95 — went out to Japanese newsgroups in December 1995, and Ruby 1.0 followed on December 25, 1996. For its first several years Ruby was effectively a Japanese-only language: the mailing lists, the documentation, and nearly the entire community were in Japanese. That changed at the turn of the millennium.
The pickaxe book opens Ruby to the world (2000)
In 2000, Dave Thomas and Andy Hunt published Programming Ruby — universally known as the “pickaxe” book for the tool on its cover — the first comprehensive English-language guide to the language. It was the bridge that let Ruby cross out of Japan. For several years the pickaxe was the canonical reference for English-speaking developers, and it seeded the early international community that would be ready and waiting when Ruby's killer application arrived a few years later.
The Rails moment (2004) — Ruby's killer app
The single biggest accelerant in Ruby's history was Ruby on Rails. Extracted from the Basecamp codebase at 37signals and released by David Heinemeier Hansson (DHH) in 2004, Rails turned Ruby from a beloved-but-niche language into a mainstream web-development platform almost overnight. Its “convention over configuration” philosophy and a famous fifteen-minute blog screencast made it the framework that defined a generation of web startups. For many developers in the mid-2000s, “learning Ruby” and “learning Rails” were the same sentence.
In 2008 the Rails team merged with the competing Merb framework, folding Merb's modularity into Rails 3 and ending a brief fork in the community's energy. Rails has continued on its own annual-ish major cadence (Rails 5, 6, 7, and 8), and remains the reason a large share of Ruby jobs exist. Rails has its own release history distinct from the language's; a dedicated Rails versions page is a natural sibling to this one if and when it ships.
The 1.9 / YARV / encoding overhaul
Ruby's interpreter was originally a tree-walking evaluator — simple, but slow. Ruby 1.9 replaced it with YARV (Yet Another Ruby VM), a bytecode virtual machine written by Koichi Sasada, delivering a large performance jump and setting the architectural foundation for a decade of later optimization. 1.9 also introduced M17N encoding-aware strings (each string carries its own encoding rather than assuming one global encoding), the modern key: value hash syntax, the -> lambda literal, block-local variables, and Fiber. The 1.9.0 release shipped on Christmas Day 2007 as an experimental preview; 1.9.1 (January 2009) was the first stable 1.9, and 1.9.3 (2011) became the widely deployed workhorse. Because 1.9 was deliberately source-incompatible with 1.8, it is the cleanest dividing line between “old” and “modern” Ruby — though, unlike Python's 2-to-3 split, the transition was relatively swift and far less painful for the ecosystem.
The 2.x maturation and the Christmas cadence
Ruby 2.0 (February 2013) was designed to be almost fully backward-compatible with 1.9.3 while adding keyword arguments, refinements, lazy enumerators, and Module#prepend. Later that year, Ruby 2.1 established the rhythm Ruby still keeps: a stable major every December 25, and a switch from patchlevel numbering to semantic versioning. The 2.x line was a steady decade of polish — generational and incremental garbage collection, symbol GC, the safe-navigation operator, frozen string literals, Hash#dig, the first JIT (MJIT in 2.6), and experimental pattern matching in 2.7 — that set the table for the performance-and-concurrency push of the 3.x era.
Ruby 3x3 — Ractor, RBS, and performance (2020)
Ruby 3.0 (December 2020) was the capstone of the multi-year “Ruby 3x3” goal Matz announced in 2015: make Ruby roughly three times faster than Ruby 2.0. Beyond raw speed, 3.0 tackled Ruby's two long-standing gaps. Ractor introduced an actor-model concurrency abstraction for genuine parallelism that sidesteps the global VM lock, and the Fiber Scheduler let ordinary blocking code run concurrently under an event loop. On the typing front, RBS (a separate signature language) and TypeProf gave Ruby an official, gradual answer to static typing without changing the language's syntax. One-line pattern matching, rightward assignment, and Hash#except rounded out the release.
The JIT arc — MJIT to YJIT to ZJIT
Ruby's just-in-time compilation story runs through three generations. MJIT (Ruby 2.6, 2018) was the first attempt — it emitted C and shelled out to the system C compiler, which limited how aggressive it could be. The breakthrough came from Shopify, whose team (led by Maxime Chevalier-Boisvert) built YJIT, a Rust-based in-process JIT introduced experimentally in Ruby 3.1, declared production-ready in 3.2, and substantially faster by 3.3. YJIT made Ruby fast enough that large Rails deployments routinely turn it on. Ruby 4.0 (2025) introduced its successor, ZJIT — a method-based compiler with an SSA intermediate representation, designed to raise the performance ceiling further and to be more approachable for outside contributors. The ZJIT launch post is by Max Bernstein on behalf of the same Shopify compiler group that built YJIT. As of 4.0 ZJIT is faster than the interpreter but not yet faster than YJIT, and ruby-core's own advice is to experiment with it rather than deploy it in production; the team's stated plan is to close the gap with YJIT, and the 4.0.0 announcement's pointer for what comes next is simply “Stay tuned for Ruby 4.1 ZJIT.” That work is visibly under way on the 4.1 development branch: in July 2026 the compiler group reported that it had enabled an inliner in ZJIT, which lets it optimize through the block-passing calls — each, map and the rest — that dominate ordinary Ruby code. In September 2026 Shopify's Ruby team reported the next step, inlining the garbage collector's allocation fastpath into ZJIT-compiled code, so that common allocations — hash, range, array and string literals, and new class instances — no longer call out to the GC's C function; its allocation microbenchmarks run roughly 1.8–3× faster.
Governance and community
Matz remains Ruby's benevolent dictator: the language's direction runs through him and the volunteer ruby-core team. Feature proposals are debated openly on the issue tracker at bugs.ruby-lang.org, and a large decision is often settled at the annual developers' meeting. The non-profit Ruby Association — a Japanese foundation established in 2011 (succeeding a 2007 LLC of the same name), chaired by Matz with Koichi Sasada on its board — supports the language's development and community, while several committers have been employed over the years by companies including Heroku (acquired by Salesforce in 2010) and Shopify specifically to work on Ruby full-time.
Ruby's community has a strong cultural identity around the MINASWAN ethos — “Matz is nice and so we are nice” — which the early conference circuit codified into a norm of welcoming, patient mentorship. It remains one of the language's most-cited distinguishing traits.
Alternative implementations
CRuby (also called MRI, the Matz Ruby Interpreter) is the reference implementation that this page tracks, but several others have shaped the ecosystem:
- JRuby — Ruby on the JVM, giving access to Java libraries and real OS-thread parallelism. The most mature alternative implementation, with its own multi-year release history.
- TruffleRuby — a high-performance implementation built on GraalVM / Truffle, capable of very aggressive JIT optimization.
- mruby — Matz's own lightweight, embeddable Ruby for devices and applications with tight memory budgets.
- Rubinius — an influential Ruby-in-Ruby implementation with an LLVM-based JIT; less active today but historically important for pushing CRuby's performance conversation forward.
Full per-version coverage of each alternative is out of scope here — JRuby in particular has its own JVM-integration arc that wouldn't fit cleanly under the canonical Ruby page.
People who shaped Ruby
Creator and core: Yukihiro “Matz” Matsumoto (creator and lead), Koichi Sasada (YARV and Ractor), Nobuyoshi Nakada (“nobu”, the prolific committer behind a huge share of CRuby patches), Yui Naruse (release manager), Yusuke Endoh (“mame”), and Aaron Patterson (“tenderlove”, Ruby and Rails core, longtime performance work).
Performance and tooling: Maxime Chevalier-Boisvert, who led the Shopify project that built YJIT, and the compiler group that carried the same work into ZJIT, Jeremy Evans (Ruby committer and Sequel / Roda author), and Kevin Newton (Prism parser). Rails lineage: David Heinemeier Hansson (DHH), who created Ruby on Rails and, more than anyone outside Matz, drove Ruby's adoption.