galaaz 2.1.7 → 2.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cee9e5a57aa8b29ef17b8b525511b422cf8c06d5d486addaa025c981045f34e
-  data.tar.gz: 2e399270c32d42df217b966c5478434f28e9aa5844db4243ef440d07f162b097
+  metadata.gz: 3e591ab4464b4ef2d75313c91b9f22de54229f2e83ed9758d66de69758e6828e
+  data.tar.gz: a8978965526f22ba7abfc1f643c20516b2f962297e2254d0fc5105a96733c7f7
 SHA512:
-  metadata.gz: 5d48ebe0a5e37459dd44237a9c0ceae8809718eb2f3396999ec6bb8123e524bf34f06e6da67467d8a0ef7b2955e99e5fc4099d14a46e56ef08e69cf25ca37c4e
-  data.tar.gz: 5e461b9065b98c347ef94665ecc809717e715da2145ebaab3410c4897c7dbc42df04492a932ada657b2b5767f3074a88c687dea2530875642f69803541b83a6b
+  metadata.gz: 3dfe41a6abb29b76ff48d9282dbce82d450975fb96b6f84eb3d564b9fda75f4220e5a773f64f59a7b416749bdcb58ab58cd63b8928ce878160d6983134ae6c80
+  data.tar.gz: 3bfcbf82a7dacbfa2357532d6fb0db4c651acd8b98d8b231da1d07cb36c7e47d73c2947773752afe80a78dc0b1b8f5c660d310887cddffba98235de984a85491

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## Unreleased
+
+## 2.1.9
+
+### Added
+
+- `rake release:bump VERSION=x.y.z` (or `bin/release_bump x.y.z`) — rewrite
+  `version.rb` and refresh `Gemfile.lock` so CI frozen `bundle install` stays in
+  sync; `rake release:check` / CI job `Gemfile.lock matches version.rb` fail early
+  with that message instead of Bundler exit 16. `make_gem` / `publish_gem` depend
+  on `release:check`.
+- Blogs: `galaaz_2_0` and `r_on_rails_ledger` (sources + rendered outputs); listed
+  in `galaaz blogs init` / `BLOG_NAMES`.
+- Brand kit under `logos/` (incl. transparent masters). PDF headers via
+  `sty/galaaz.sty`: small logo left, upright page number + italic uppercase
+  section title right; optional `\galaazheaderfrompage` (shared
+  `sty/galaaz-headers-from-p3.tex` for title/TOC + splash). Main blogs share
+  HTML `before_body` lockup + PDF splash; `galaaz blogs init` / `add tex`
+  install sty header PNG and the from-p3 override.
+- Omarchy menu brand mark: monochrome icon font `galaaz` (`U+E900`, source
+  `logos/icon-font/`) installed to `~/.local/share/fonts/galaaz/` by
+  `galaaz omarchy` / core installer — replaces the Ruby-on-Rails Nerd Font gem.
+
+### Fixed
+
+- `galaaz add ledger`: run `rails tailwindcss:build` after seed so Propshaft finds
+  `tailwind.css` (builds dir is gitignored).
+- Sync `Gemfile.lock` path gem with `version.rb` on every release bump (CI frozen
+  install).
+
+## 2.1.8
+
+### Fixed
+
+- `galaaz add ledger`: always `bundle install` under `mise x` (honours app `.ruby-version`),
+  ensure the lockfile's bundler is installed, then `bundle update galaaz` and
+  `bundle exec` for setup/rails — avoids Omarchy PATH Ruby 4.x mixing with ledger
+  Ruby 3.3 and "gems not found" / wrong bundler errors.
+
 ## 2.1.7
 
 ### Added

data/Rakefile

@@ -220,12 +220,30 @@ blogs.each do |dir|
 
 end
 
+#===========================================================================================
+# Release helpers: keep version.rb and Gemfile.lock in sync (CI frozen install)
+#===========================================================================================
+
+namespace :release do
+  desc 'Fail if version.rb does not match the PATH galaaz version in Gemfile.lock'
+  task :check do
+    ruby 'bin/check_gemfile_lock_version'
+  end
+
+  desc 'Set version.rb to VERSION=x.y.z and refresh Gemfile.lock (bundle lock)'
+  task :bump do
+    new_ver = ENV['VERSION'].to_s.strip
+    abort 'Usage: rake release:bump VERSION=x.y.z' if new_ver.empty?
+    ruby 'bin/release_bump', new_ver
+  end
+end
+
 #===========================================================================================
 # Makes a gem for publishing in RubyGems
 #===========================================================================================
 
 desc 'Makes a Gem'
-task :make_gem do
+task :make_gem => 'release:check' do
   (sh %{ gem build #{$gem_name}.gemspec })
 end
 
@@ -234,7 +252,7 @@ end
 #===========================================================================================
 
 desc 'Publish gem to rubygems'
-task :publish_gem do
+task :publish_gem => 'release:check' do
   (sh %{ gem push #{$gem_name}-#{$version}.gem })
 end
 

data/bin/check_gemfile_lock_version

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Fail if version.rb and the PATH galaaz entry in Gemfile.lock disagree.
+# CI runs this before frozen bundle install so the failure is obvious
+# (instead of Bundler exit 16 from ruby/setup-ruby).
+
+root = File.expand_path('..', __dir__)
+version_rb = File.join(root, 'version.rb')
+lock_path = File.join(root, 'Gemfile.lock')
+
+abort "missing #{version_rb}" unless File.file?(version_rb)
+abort "missing #{lock_path}" unless File.file?(lock_path)
+
+version_src = File.read(version_rb)
+declared = version_src[/\$version\s*=\s*["']([^"']+)["']/, 1]
+abort "could not parse $version from version.rb" if declared.nil? || declared.empty?
+
+lock = File.read(lock_path)
+# Prefer the PATH gemspec block (first galaaz version under PATH … specs:).
+path_block = lock[/\APATH\n.*?^GEM\n/m]
+locked =
+  if path_block
+    path_block[/^\s+galaaz \(([^)]+)\)/, 1]
+  end
+locked ||= lock[/^\s+galaaz \(([^)]+)\)/, 1]
+abort 'could not parse galaaz version from Gemfile.lock PATH specs' if locked.nil? || locked.empty?
+
+if declared == locked
+  puts "OK: version.rb (#{declared}) matches Gemfile.lock path gem (#{locked})"
+  exit 0
+end
+
+warn <<~MSG
+  version.rb and Gemfile.lock disagree.
+
+    version.rb  $version = #{declared}
+    Gemfile.lock PATH galaaz (#{locked})
+
+  After bumping the gem version, refresh the lockfile in the same commit:
+
+    rake release:bump VERSION=#{declared}
+
+  Or: bundle lock && git add Gemfile.lock
+MSG
+exit 1

data/bin/release_bump

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Bump version.rb and refresh Gemfile.lock so CI frozen bundle install stays valid.
+# Usage: bin/release_bump x.y.z
+
+root = File.expand_path('..', __dir__)
+new_ver = ARGV[0].to_s.strip
+abort 'Usage: bin/release_bump x.y.z' unless new_ver.match?(/\A\d+\.\d+\.\d+(?:[.-][\w.]+)?\z/)
+
+path = File.join(root, 'version.rb')
+src = File.read(path)
+unless src.sub!(/\$version\s*=\s*["'][^"']+["']/, "$version=\"#{new_ver}\"")
+  abort "could not rewrite $version in #{path}"
+end
+File.write(path, src)
+puts "Wrote version.rb $version=#{new_ver}"
+
+Dir.chdir(root) do
+  ok = system('bundle', 'lock')
+  abort 'bundle lock failed' unless ok
+  ok = system(RbConfig.ruby, File.join(root, 'bin/check_gemfile_lock_version'))
+  abort 'version check failed after bump' unless ok
+end
+
+puts 'Next: update CHANGELOG.md, commit version.rb + Gemfile.lock, then rake make_gem && rake publish_gem'

data/blogs/README.md

@@ -21,6 +21,8 @@ Examples:
 bin/gknit blogs/oh_my/oh_my.Rmd
 bin/gknit blogs/gknit/gknit.Rmd
 bin/gknit blogs/galaaz_ggplot/galaaz_ggplot.Rmd
+bin/gknit blogs/galaaz_2_0/galaaz_2_0.Rmd
+bin/gknit blogs/r_on_rails_ledger/r_on_rails_ledger.Rmd
 bin/gknit blogs/manual/manual.Rmd
 bin/gknit blogs/nse_dplyr/nse_dplyr.Rmd
 bin/gknit blogs/ruby_plot/ruby_plot.Rmd
@@ -36,6 +38,8 @@ From the project root:
 rake blog:oh_my
 rake blog:gknit
 rake blog:galaaz_ggplot
+rake blog:galaaz_2_0
+rake blog:r_on_rails_ledger
 rake blog:manual
 rake blog:nse_dplyr
 rake blog:ruby_plot

data/blogs/galaaz_2_0/galaaz_2_0.Rmd

@@ -0,0 +1,385 @@
+---
+title: "Galaaz 2.0: Ruby meets real GNU R (again)"
+subtitle: "NewBridge, JRuby or CRuby, CRAN/Bioconductor, and Arrow-shaped data paths"
+author: "Rodrigo Botafogo"
+tags: [Galaaz, "Galaaz 2.0", Ruby, R, JRuby, CRuby, "GNU R", NewBridge, Arrow, knitr, gknit]
+date: "2026"
+output:
+  html_document:
+    self_contained: true
+    keep_md: true
+    toc: true
+    toc_float: true
+    toc_depth: 2
+    number_sections: true
+    includes:
+      before_body: _logo_before_body.html
+  pdf_document:
+    includes:
+      in_header:
+        - "../../sty/galaaz.sty"
+        - "../../sty/galaaz-headers-from-p3.tex"
+    keep_tex: yes
+    number_sections: yes
+    toc: true
+    toc_depth: 2
+fontsize: 11pt
+---
+
+```{r setup, echo=FALSE}
+options(width = 70)
+```
+
+```{ruby setup_ruby, echo=FALSE}
+ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] ||= '300'
+ENV['GALAAZ_JOBS_DIR'] ||=
+  File.join(Dir.tmpdir, 'galaaz_jobs_galaaz_2_0')
+R.options(crayon__enabled: false, width: 70)
+```
+
+```{r brand_logo, echo=FALSE, fig.align='center', out.width='45%', eval=knitr::is_latex_output()}
+# PDF only — HTML uses _logo_before_body.html (above the TOC).
+knitr::include_graphics("images/galaaz-lockup-stacked.png")
+```
+
+# Introduction
+
+Ruby is excellent for web apps, orchestration, and expressive object models.
+It has never matched **R** for statistics, Bioconductor pipelines, or the
+depth of CRAN. **Python** closed a similar gap with NumPy, pandas, and a
+huge scientific ecosystem. For Ruby, the practical answer is not to
+reimplement that world — it is to **drive real R** from idiomatic Ruby.
+
+**Galaaz** is that coupling. An earlier line of work ran on Oracle’s
+**GraalVM** with **TruffleRuby** and **FastR** in one JVM. **Galaaz 2.0**
+is a different architecture: **JRuby or CRuby** talk to **standard GNU R**
+over a process bridge we call **NewBridge**. You keep CRAN and Bioconductor
+(including compiled packages), and you keep a normal Ruby toolchain.
+
+This post is the 2.0 story: what changed, how the bridge works, how to pin
+R versions in containers, how data moves (including **Apache Arrow**), and
+how to keep the bridge free for long R jobs. Deep API detail lives in the
+[Galaaz Manual](https://rbotafogo.github.io/galaaz/); here we stay at
+blog length with a few runnable sketches.
+
+# What changed
+
+| | Historical stack | Galaaz 2.0 |
+|---|---|---|
+| Ruby | TruffleRuby (Graal) | **JRuby** or **CRuby** |
+| R | FastR (subset of GNU R) | **GNU R** (CRAN / Bioconductor) |
+| Coupling | Same-JVM interop | **NewBridge** (separate processes) |
+| Install | Special Graal distribution | `gem install` + compile gatekeeper |
+| Legacy tools | `grun`, polyglot `gknit-draft` | `bin/galaaz-ruby`, `bin/gknit` |
+
+Ideas from the older articles still matter — ggplot layers, dplyr pipes,
+gKnit literate docs — but the **engine** underneath is different. If you
+land on a 2018 “Ruby + R on GraalVM” post, treat the plots and narrative
+as inspiration and this post (plus the manual) as the current stack.
+
+# NewBridge in one picture
+
+Galaaz 2.0 does **not** embed Renjin or FastR. Roughly:
+
+1. Your **Ruby** process (JRuby or CRuby) loads Galaaz.
+2. A native **gatekeeper** (`ext/new_bridge`, Rcpp / C++) mediates the protocol.
+3. A **GNU R** process evaluates calls, holds large objects, and runs packages.
+
+Ruby stays Ruby: `R.mean`, `E.aes`, method chaining, classes and modules.
+R stays R: the same `lm`, `DESeq2`, or `ggplot2` you would run in RStudio.
+Large panels should usually **stay in R**; Ruby orchestrates and pulls
+small results (Remote Control). Opt in to unbox scalars when you need a
+plain Ruby number (`>> 0` for length-1 vectors is the common 2.0 idiom).
+
+A minimal session looks like this:
+
+```{ruby hello_bridge}
+require 'galaaz'
+
+puts R.sum(R.c(1, 2, 3, 4, 5))
+mtcars = ~R[:mtcars]
+puts mtcars.dim
+puts R.summary(mtcars.mpg)
+```
+
+Callbacks still exist: Ruby procs can be registered so R code can call
+back into Ruby when a package expects an R function. That path is
+documented in the manual; the important product point is that **real
+GNU R** is on the other end of the wire.
+
+# Either Ruby engine
+
+NewBridge is tested on both:
+
+* **JRuby** (e.g. 10.x + JDK 21) — real OS threads, JVM ecosystem, natural
+  fit for Rails under load.
+* **CRuby** (e.g. 3.3+) — MRI gem ecosystem, familiar for many Ruby shops.
+
+The public API is the same. Launchers honor **`GALAAZ_RUBY`**.
+Use **`bin/galaaz-ruby`**, or **`bin/galaaz-jruby`** to force JRuby.
+Prefer **JRuby** when you want parallel Ruby threads feeding R;
+prefer **CRuby** when your app and gems already live there. Arrow
+helpers need engine-specific native bits (Java Arrow + `JAVA_OPTS`
+nio opens on JRuby; Arrow GLib + `red-arrow` on CRuby) — see the
+manual’s Arrow section.
+
+```bash
+# From a checkout or installed layout:
+bin/galaaz-ruby -e \
+  'require "galaaz"; puts R.R__version[["version.string"]]'
+GALAAZ_RUBY=jruby bin/galaaz-ruby -e \
+  'require "galaaz"; puts R.pi'
+```
+
+# Multiple R versions via containers
+
+Because R is a **separate process**, the Ruby gem does not hard-wire one
+R build. Whatever `R` / `Rscript` is on `PATH` (and can load the
+gatekeeper) is the R you drive. That makes **containers** a clean way to
+pin versions:
+
+* Image A: Ubuntu + **R 4.3** + system libs for your Bioconductor set.
+* Image B: same app code + **R 4.4** (or a rocker image) for comparison.
+* Your Galaaz gem and Ruby code stay the same; only the image’s R changes.
+
+Sketch (conceptual):
+
+```bash
+# Dev against the R that the image provides
+docker run --rm -it myorg/galaaz-r43 \
+  bin/galaaz-ruby script/analysis.rb
+
+docker run --rm -it myorg/galaaz-r44 \
+  bin/galaaz-ruby script/analysis.rb
+```
+
+Inside each image, `R --version` differs; NewBridge still speaks the same
+protocol. For a first taste without building your own Dockerfile, the
+repo ships **try** images and runners:
+
+```bash
+# From a Galaaz checkout
+./docker/try-gstudio/run.sh   # JRuby + gstudio-oriented image
+./docker/try-cruby/run.sh     # CRuby try image
+```
+
+**Cold-install** proofs (`docker/cold-install`,
+`docker/cold-install-cruby`) install the gem on a throwaway Ubuntu and
+compile the gatekeeper — useful when you want “empty machine → working
+bridge” confidence. Multi-runtime Docker R matrices are still evolving
+(slow integration coverage); the sketch above is the pattern to build on.
+
+# Moving data: Apache Arrow
+
+Crossing a process boundary means you must be honest about **copies**.
+Galaaz’s Arrow roadmap has three stages:
+
+| Stage | Idea | Status |
+|---|---|---|
+| **A** | Copy columnar data into R; return an R-side Arrow/proxy handle | Available (`from_ruby_batches`, `table_from`, …) |
+| **B** | Same-machine **IPC file**: bulk bytes stay off the MsgPack bridge; only a **file path** crosses NewBridge | Shipped (two directions: B1 and B2) |
+| **C** | Shared-memory bus (true shared RAM) | Future |
+
+Do **not** read Stage A as “zero-copy shared RAM.” Stage A is “build the
+table in R efficiently, then Remote-Control it.” Stage B is still a
+file/`mmap` handoff on one machine—not Stage C—but it keeps large
+columns out of the control plane.
+
+## Stage B in plain words
+
+**IPC** here means Apache Arrow’s **Inter-Process Communication** file
+format: a portable columnar dump on disk (often under `/dev/shm` so it
+lives in RAM-backed tmpfs). Ruby and R never shove megabytes through
+NewBridge; they agree on a path, then each side’s Arrow stack
+reads or writes that file.
+
+Stage B splits by **direction**:
+
+* **B1 — Ruby → R (ingest).** Ruby writes an IPC file
+  (`Galaaz::ArrowIpc.write` / `write_batches`). R opens it with
+  `R::Arrow.open_ipc(path)` and gets a table proxy for dplyr or
+  modeling. After R has materialised the table, Ruby can
+  `Galaaz::ArrowIpc.release(path)` (unlink the scratch file).
+* **B2 — R → Ruby (export).** After analytics in R, `R::Arrow.write_ipc`
+  writes another IPC file and returns its path over the bridge. Ruby
+  reads columns or row hashes with `Galaaz::ArrowIpc.read` /
+  `read_batches`—handy when the next step is a DB write or an API
+  payload in Ruby.
+
+Needs: R package `arrow`, plus a Ruby writer/reader (CRuby:
+**red-arrow**; JRuby: Arrow Java JARs). Specs skip when those are
+missing; the sketch below does the same.
+
+## Stage B sketch (B1 ingest + B2 export)
+
+This is the path to prefer for large same-machine handoffs. Ruby
+threads build row batches; **B1** writes one IPC file and R opens it by
+path; dplyr summarises in R; **B2** writes the result IPC and Ruby
+reads row hashes. NewBridge only carries paths.
+
+```{ruby arrow_ipc_b12, message=FALSE, warning=FALSE}
+ipc_ok = Galaaz::ArrowIpc.available? &&
+  (R::Support.eval(
+    "requireNamespace('arrow', quietly=TRUE) && " +
+    "requireNamespace('dplyr', quietly=TRUE)") == true)
+unless ipc_ok
+  puts '(Skip: need Arrow IPC backend + R arrow/dplyr.)'
+else
+  thread_count = 2
+  rows_per_thread = 250
+  group_count = 5
+  batches = []
+  mutex = Mutex.new
+  threads = []
+
+  thread_count.times do |tid|
+    threads << Thread.new do
+      start = tid * rows_per_thread
+      local = (start...(start + rows_per_thread)).map do |i|
+        {
+          id: i,
+          grp: "g#{i % group_count}",
+          value: (i % 17) + 1,
+          weight: ((i % 5) + 1) * 0.5
+        }
+      end
+      mutex.synchronize { batches << local }
+    end
+  end
+  threads.each(&:join)
+
+  paths = []
+  begin
+    # B1: Ruby → IPC file → R table proxy
+    # write_batches wants flat row Hashes (not nested batches)
+    in_path = Galaaz::ArrowIpc.write_batches(batches.flatten)
+    paths << in_path
+    tbl = R::Arrow.open_ipc(in_path)
+    puts "R class: #{tbl.rclass}"
+    puts "IPC in: #{File.basename(in_path)}"
+
+    grouped = R.dplyr___group_by(tbl, :grp)
+    summed = R.dplyr___summarise(
+      grouped,
+      n: E.n(),
+      total: E.sum(:value),
+      wsum: E.sum(R[:value] * R[:weight])
+    )
+
+    # B2: R → IPC file → Ruby row hashes
+    out_path = R::Arrow.write_ipc(summed)
+    paths << out_path
+    rows = Galaaz::ArrowIpc.read_batches(out_path)
+    puts "IPC out: #{File.basename(out_path)}"
+    rows.first(5).each do |r|
+      puts "#{r[:grp]} n=#{r[:n]} " +
+           "total=#{r[:total]} wsum=#{r[:wsum]}"
+    end
+
+    total_n = rows.map { |r| r[:n].to_i }.sum
+    expect_n = thread_count * rows_per_thread
+    puts "Sum of n (expect #{expect_n}): #{total_n}"
+  ensure
+    paths.each { |p| Galaaz::ArrowIpc.release(p) }
+  end
+end
+```
+
+What to notice: `write_batches` / `open_ipc` is **B1**; after dplyr,
+`write_ipc` / `read_batches` is **B2**. Specs:
+`arrow_ipc_handoff_spec.rb`, `arrow_ipc_export_spec.rb`. Deeper notes:
+`Documentation/ROADMAP_ARROW_RUBY_R.md`.
+
+## Stage A (still useful)
+
+Stage A copies batches straight into R with
+`R::Arrow.from_ruby_batches`—no IPC file. Fine for modest tables or
+when you do not have a Ruby Arrow writer installed. Same threaded
+shape as above, one call instead of B1:
+
+```{ruby arrow_pipeline, message=FALSE, warning=FALSE}
+arrow_ok = R::Support.eval(
+  "requireNamespace('arrow', quietly=TRUE) && " +
+  "requireNamespace('dplyr', quietly=TRUE)")
+unless arrow_ok == true
+  puts '(Skip: need arrow + dplyr in R.)'
+else
+  batches = [
+    [{ id: 1, grp: 'a', value: 10, weight: 1.0 },
+     { id: 2, grp: 'b', value: 20, weight: 0.5 }],
+    [{ id: 3, grp: 'a', value: 30, weight: 1.5 }]
+  ]
+  tbl = R::Arrow.from_ruby_batches(batches)
+  puts "R class: #{tbl.rclass}"
+  grouped = R.dplyr___group_by(tbl, :grp)
+  summarised = R.dplyr___summarise(
+    grouped, n: E.n(), total: E.sum(:value))
+  out = R.dplyr___collect(summarised)
+  puts R.as__data__frame(out)
+end
+```
+
+Larger Stage A demos live in `arrow_from_ruby_batches_spec.rb` and
+`arrow_large_pipeline_spec.rb` (under `specs/` / `slow-specs/`).
+
+# Keeping the bridge free
+
+Two different “don’t block” stories:
+
+* **`R::Async` / `R.eval_r_async`** — free a **Ruby** thread while the
+  **same** bridge R process works. Good for short/medium calls when you
+  still want one R session.
+* **`R::Job`** — run heavy work in a **child `Rscript`**. The bridge
+  stays free for other traffic. Package installs
+  (`R.install_and_loads`) use this path so `make`/`gcc` do not wedge
+  the gatekeeper.
+
+```{ruby job_lm, message=FALSE, warning=FALSE}
+begin
+  coef = R::Job.eval(<<~R) { |job| job.load_rds }
+    fit <- lm(mpg ~ wt, data = mtcars)
+    saveRDS(unname(coef(fit)), result_path)
+  R
+  puts coef
+rescue => e
+  puts e.class.to_s
+  e.message.to_s.scan(/.{1,68}/).each { |line| puts line }
+end
+```
+
+Rule of thumb: short interactive analytics on the bridge; installs and
+multi-minute fits in **`R::Job`**. Details and timeouts
+(`GALAAZ_INSTALL_TIMEOUT_SEC`, `GALAAZ_JOBS_DIR`) are in the manual.
+
+# What stayed the same
+
+Galaaz 2.0 is a new **runtime**, not a new plotting language. These still
+apply:
+
+* **ggplot2** from Ruby — see *Ruby Plotting with Galaaz* /
+  *Beautiful Ruby Plots*.
+* **dplyr / NSE** — see *Non Standard Evaluation in dplyr with Galaaz*.
+* **Literate docs** — **gKnit** still wraps knitr so Ruby chunks render
+  next to R (HTML/PDF).
+* **Classes, modules, procs** — the *oh my* S4 comparison still teaches
+  structure; unwrap and bridge details follow 2.0 rules.
+
+R-on-Rails (Ruby web + R science) is the product framing: Rails (or any
+Ruby app) orchestrates; GNU R computes.
+
+# Conclusion
+
+**Galaaz 2.0** bets on **boring, powerful defaults**: standard Ruby
+engines, standard GNU R, a clear process bridge, containers to pin R,
+and Arrow-shaped paths for larger tables — with zero-copy shared memory
+still on the roadmap. The Graal-era prototype proved the *idea*; 2.0
+makes the *ecosystem* reachable.
+
+## Further reading
+
+* Manual (GitHub Pages): https://rbotafogo.github.io/galaaz/
+* Arrow roadmap: `Documentation/ROADMAP_ARROW_RUBY_R.md`
+* Repo blogs under `blogs/` (ggplot, dplyr, gKnit, oh my, manual)
+* Try images: `docker/try-gstudio`, `docker/try-cruby`
+* Older Graal-era plot narrative (historical): search
+  “Ruby Plotting with Galaaz in GraalVM” on Towards Data Science