Lore

A timeline of how this codebase grew over three decades. Dates are derived from git history (this repo) and from public release notes.

Eras

The pre-Git era (Feb 1993 – Jan 1998)

Ruby was designed and prototyped by Yukihiro "Matz" Matsumoto starting 24 February 1993 (include/ruby/version.h records the birth date). The first public release, Ruby 0.95, was announced on fj.sources in December 1995. Versions 1.0 through 1.4 were tracked in CVS on Matz's machines and on ftp.netlab.co.jp. None of those commits exist in this Git history; they appear only as "imported from CVS" footprints in the early Git import.

CVS-to-Git import (Jan 1998 – present in history)

The earliest commits in this repository are:

392296c12d  New repository initialized by cvs2svn.
3db12e8b23  Initial revision
62e41d3f2e  Initial revision

These were synthesized when CVS history was dumped to Subversion in the early 2000s, and again when SVN was migrated to Git in April 2019. The contents at these commits are Ruby 1.x.

The Ruby 1.6 / 1.8 era (2000 – 2007)

Ruby 1.6 (Sep 2000) and 1.8 (Aug 2003) cemented the syntax most Rubyists still recognise. The implementation in this period was a tree-walking interpreter — no bytecode. The eval.c family, gc.c, and parse.y were already present, with parse.y being a massive Bison grammar.

Notable in this era:

• Onigmo regex engine (initially Oniguruma) replaced the original GNU regex code (~2003). regcomp.c/regexec.c/regparse.c/regenc.c come from that era.
• The mkmf convention for C extensions (lib/mkmf.rb) stabilised, and many of today's ext/* extensions trace back to this era.

The YARV revolution (2007 – 2013)

Ruby 1.9 (Dec 2007) was a near-total rewrite of the interpreter:

• YARV (Yet Another Ruby VM) — a stack-based bytecode VM by Koichi Sasada — replaced the tree-walking eval. This is the VM still in use today: vm.c, vm_eval.c, vm_exec.c, compile.c, iseq.c, insns.def.
• M17N: every string carries an encoding (encoding.c, transcode.c, enc/).
• Native threads replaced Ruby-level green threads (thread_pthread.c, thread_win32.c), introducing the GVL.
• Fibers were added (cont.c, with assembly under coroutine/).

The 2.x era (2013 – 2020)

• 2.0 (Feb 2013): refinements, keyword arguments, Module#prepend.
• 2.1 (Dec 2014): introduces the generational garbage collector (RGenGC) in gc.c.
• 2.2 (Dec 2015): incremental GC, symbol GC.
• 2.3 (Dec 2016): frozen string literals, the safe navigation operator (&.).
• 2.5 (Dec 2017): top-level rescue/ensure/else in method bodies.
• 2.6 (Dec 2018): introduces MJIT, a method-based JIT that wrote out C and shelled out to GCC/Clang. MJIT was later superseded by YJIT.
• 2.7 (Dec 2019): pattern matching (experimental), beginless ranges, Method#=>. Last release before the Ruby 3 push.

Ruby 3x3 and Ractor (Dec 2020)

Ruby 3.0 shipped in December 2020 with three landmark features:

• Ractor (ractor.c, ractor_sync.c) — actor-style parallel execution that bypasses the GVL.
• Scheduler / Fiber Scheduler (scheduler.c) — pluggable async IO via Fibers.
• Static analysis hooks (RBS, TypeProf) shipped alongside core.

The "3x3" goal — three times faster than Ruby 2.0 — drove the JIT investments that culminated in YJIT.

YJIT lands (Oct 2021 – Dec 2022)

YJIT was developed by Maxime Chevalier-Boisvert at Shopify and merged into ruby/ruby in October 2021 for Ruby 3.1, originally written in C. In Ruby 3.2 (Dec 2022) it was rewritten in Rust (yjit/src/), making this the first Rust code shipped in the canonical Ruby implementation. The C entry point lives in yjit.c; the workspace and crates live under yjit/.

Prism replaces parse.y (2023 – present)

Prism (formerly YARP — Yet Another Ruby Parser) is a hand-written portable C parser by Kevin Newton at Shopify. It was merged into Ruby in 2023 as prism/, and was promoted to a full peer of parse.y in Ruby 3.3 (Dec 2023). Both parsers are still maintained in this tree; users select via --parser=.

Lrama replaces GNU Bison (Dec 2023)

Bundled GNU Bison was historically required to build CRuby. Lrama — a Ruby-implemented Bison-compatible parser generator (tool/lrama/) — replaced it in Ruby 3.3 (Dec 2023). The build no longer needs Bison installed.

ZJIT arrives (2024 – present)

A second Rust JIT, ZJIT, landed under zjit/ during the Ruby 3.4 / 4.0 development cycle. It uses a higher-level IR (zjit/src/hir.rs, zjit/src/lir.rs) and is being developed as a long-term successor or sibling to YJIT. As of this checkout (Ruby 4.1.0 dev), both JITs ship together.

Ruby 4.0 (Dec 2025) and beyond

Ruby 4.0 shipped in December 2025. The version number jump reflects naming convention more than a hard break (the team has explicitly said major version changes are not catastrophic API breaks). This checkout is the 4.1.0 development branch.

Longest-standing features

Feature	First in this tree	Notes
parse.y LALR grammar	Pre-1998	Still the default parser
gc.c mark-sweep collector	Pre-1998	Heavily evolved (incremental, generational, compacting), still recognisable
eval.c and the C-API surface	Pre-1998	The rb_* C API has not had a major break
mkmf.rb extension build	Pre-2000	Still how every C extension is configured

Deprecated / removed

Feature	Era	Replaced by
Tree-walking eval	Pre-1.9	YARV bytecode VM
Green threads	Pre-1.9	Native pthreads + GVL
MJIT (C-based JIT)	2.6 – 3.2	YJIT (Rust, in-process)
Bundled GNU Bison	Pre-3.3	Lrama (tool/lrama/)
Continuation	Discouraged since 1.9	Fiber
safe_level / $SAFE	Removed in 3.0	n/a

Major rewrites

• 1.9 → YARV (2007): tree walker replaced by a stack VM. Still the architecture today.
• YJIT C → YJIT Rust (3.2, Dec 2022): the first Rust code in the canonical Ruby tree.
• Bison → Lrama (3.3, Dec 2023): build system no longer requires Bison.
• Parsing: parse.y joined by Prism (3.3): two coexisting parsers, switchable per-run.

Growth trajectory

The repository has accumulated roughly 98,500 commits across nearly three decades. Active monthly contributors numbered in the dozens during the 2.x era and have been steady or growing since YJIT and Prism brought new contributor groups onboard. Bundled gem syncs (tool/sync_default_gems.rb) account for a meaningful slice of merge traffic — many "Ruby" commits originate in standalone gem repositories like ruby/prism, ruby/optparse, and rubygems/rubygems.