galaaz 2.1.3 → 2.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '085fd47fe76016fb5b078f3c44a02100a7d9af05c2f7cf9e19ded83058947c8e'
-  data.tar.gz: 19f36b20968fd4456ad95024f2a33dbde60dfdf62a3bbda295d49e08a8c32bc7
+  metadata.gz: d39a98e695448ffb0166d33746445cc0076efcbd15e6f34250c99512e7c8e71d
+  data.tar.gz: eff6228e3febeb502838f1a6b99e38d03186327678b1a5535e58e8548e516d72
 SHA512:
-  metadata.gz: c7db477fca2f6de435d9eb6bd5ccc5ee709a779e3a5816febc9a0eda9be51f5f18812af79889e7fd4ce1e5facd79a080e80a98829381b19670d6a380765554c4
-  data.tar.gz: 6ba4144e49328b6bb70188ab6330ed086f969cb952076758db0207171c54c2ff41e6fb21c8666a6cd87b459f47b2786a31edf8f1f1b98343d7d536aae902de36
+  metadata.gz: ffe309c54323c08acabe1752c677cd67090878170b33853eb739195f4be36450379b2e100dc5e9ecfa317e4e4373aed8082dfee8407bb5231cd1d5b41c6fbdf2
+  data.tar.gz: daef47d66a2f3c20e2e430797ffd6193e9d80cde6ffc9b82856835dab4c0a3e3f8833b17d1b6b3389e4e5e3c5a7cccba8aee42d9b023b2e110758b6e678e9a2c

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 2.1.5
+
+### Fixed
+
+- `gknit` / `gknit_Rscript`: resolve input with `File.expand_path` so absolute paths
+  (e.g. `~/galaaz-blogs/...`) are not prefixed with `Dir.pwd` (broke when run from
+  `~/.local/bin`).
+- `galaaz add ledger`: do not strip app Ruby version pins; keep engine-agnostic
+  RubyGems `gem "galaaz"` rewrites only.
+
+### Changed
+
+- Omarchy `omarchy-galaaz-add`: install pandoc via `pandoc-bin` or the latest GitHub
+  linux binary into `~/.local/bin` — not Arch `pandoc` / `pandoc-cli` (Haskell deps).
+- Omarchy menu Docs / GitHub rows use `omarchy-launch-webapp` (same as Omarchy Learn).
+- `galaaz add arrow` / ledger path: prefer Apache `LIBARROW_BINARY` prebuilt libarrow
+  (avoid Arch pacman arrow version skew on Omarchy).
+
+## 2.1.4
+
+### Added
+
+- **`R::Job`**: long CRAN installs (and arbitrary R via `R::Job.eval`) run in a **child
+  Rscript** process, not on the NewBridge gatekeeper. Logs and metadata live under
+  `~/.local/share/galaaz/jobs/` (override with `GALAAZ_JOBS_DIR`). One install at a
+  time (`install.lock`). Bridge R stays free while Ruby awaits the job. Clears stale
+  `00LOCK-<pkg>` dirs before install (left behind after kill-on-timeout).
+- **Layer C:** `R::Job.eval` / `R::Job.script` for long arbitrary R. Child gets
+  `setwd(job.dir)`, `GALAAZ_JOB_DIR`, and `result_path` (default `result.rds`). After
+  success, `job.load_rds` does a short sync `readRDS` on the bridge. Block form
+  awaits and yields the job (`coef = R::Job.eval(code) { |j| j.load_rds }`).
+  Documented in the manual section **Background R jobs (`R::Job`)** (README /
+  `blogs/manual/manual.Rmd`).
+
+### Changed
+
+- `R.install_rlibs` / `R.install_and_loads` use `R::Job.install` and **await until
+  finished** by default (no bridge 60s install timeout). Optional await limit via
+  `install_timeout_sec:` or `GALAAZ_INSTALL_TIMEOUT_SEC` (also `gknit
+  --install_timeout_sec`); on timeout the child process group is killed so compile
+  work cannot OOM the shell. gknit reports install-job timeouts in the internal
+  error summary.
+
 ## 2.1.3
 
 ### Fixed
@@ -85,4 +128,6 @@ Galaaz 2.0 drives **GNU R** from **JRuby** or **CRuby** over a process bridge. I
 - `grun`, `gknit_Rscript`, and the polyglot path in `gknit-draft` are leftover from the Graal era; use `galaaz-jruby` / `gknit` (or `GALAAZ_RUBY=ruby` for CRuby).
 - The gatekeeper must be compiled on the install machine (Rcpp + C++ toolchain); it is not a prebuilt binary in the gem.
 - Multi-runtime Docker R (Phase 4.5) is a slow integration spec, not part of cold-install CI.
-- The gknit installation-timeout spec is skipped pending a dedicated pass; SimpleCov is a development gem and is not installed in the smoke image.
+- The gknit installation-timeout spec covers `R::Job` await timeouts
+  (`GALAAZ_INSTALL_TIMEOUT_SEC`); SimpleCov is a development gem and is not installed in
+  the smoke image.

data/README.md

@@ -2,7 +2,7 @@
 title: "Galaaz Manual"
 subtitle: "R-on-Rails: GNU R meets Ruby for the web"
 author: "Rodrigo Botafogo"
-tags: [Galaaz, "R-on-Rails", Ruby, Rails, JRuby, R, "GNU R", ggplot2, knitr, dplyr, Bioconductor, Arrow]
+tags: [Galaaz, "R-on-Rails", Ruby, Rails, JRuby, CRuby, R, "GNU R", ggplot2, knitr, dplyr, Bioconductor, Arrow]
 date: "2026"
 bibliography: "../../examples/Bibliography/stats.bib"
 output:
@@ -73,7 +73,7 @@ rewrite in another stack. **R-on-Rails** means:
 1. **Keep your science in R** — packages, formulas, plots, Bioconductor, the same engine as RStudio.
 2. **Learn enough Ruby/Rails** — routes, controllers, views, jobs, auth—not a second statistics career.
 3. **Call R from the app** — Galaaz loads R behind the scenes; long jobs can complete asynchronously
-   while Rails stays responsive (see later sections on the bridge and `R::Async`).
+   while Rails stays responsive (see later sections on the bridge, `R::Async`, and `R::Job`).
 4. **Ship alone when you need to** — one developer can own both the analysis and the product UI,
    without waiting for a separate “stats engineer” and “Rails engineer.”
 
@@ -358,7 +358,13 @@ A **table of all `bin/` scripts** (bootstrap, Ruby launcher, gstudio, gknit, tes
    **`bin/run_all_rspec`** (same `GALAAZ_RUBY` rule). **`bin/galaaz-jruby`** remains a thin
    wrapper that forces JRuby.
 
-A **gstudio** try image (JRuby + R + Galaaz already installed) is **`docker run --rm -it ghcr.io/rbotafogo/galaaz-try:gstudio`** (or **`./docker/try-gstudio/run.sh`** from a checkout). Maintainers can prove a RubyGems install on a throwaway Ubuntu machine (no repo inside the container) with **`./docker/cold-install/run.sh published-specs`** (JRuby) or **`./docker/cold-install-cruby/run.sh published-specs`** (CRuby).
+A **gstudio** try image with Galaaz already installed is available for both engines:
+**JRuby** — `docker run --rm -it ghcr.io/rbotafogo/galaaz-try:gstudio` (or
+`./docker/try-gstudio/run.sh` from a checkout); **CRuby** —
+`docker run --rm -it ghcr.io/rbotafogo/galaaz-try:cruby` (or `./docker/try-cruby/run.sh`).
+Maintainers can prove a RubyGems install on a throwaway Ubuntu machine (no repo inside
+the container) with `./docker/cold-install/run.sh published-specs` (JRuby) or
+`./docker/cold-install-cruby/run.sh published-specs` (CRuby).
 
 ## Windows + WSL2 (optional: Docker / R in a container)
 
@@ -394,11 +400,18 @@ WSL integration is enabled for the distro where Galaaz is installed.
 ``` ruby
   vec = R.c(1, 2, 3, 4)
   puts vec
+
+  # R.foo(...) calls an R *function*. Datasets are objects — fetch with ~:
+  df = ~R[:mtcars]
+  puts R.summary(df)
 ```
 
 ```
 ## [1] 1 2 3 4
 ```
+
+(`R.mtcars` is wrong: it becomes `mtcars()` in R and fails. With
+`using Galaaz::SymbolDSL`, the short form `~:mtcars` also works.)
   
 * Run all specs
 
@@ -456,8 +469,13 @@ driver). For concurrency tests on the bridge itself, see `specs/bridge_concurren
 
 ## Long-running R calls and a completion block
 
-For R work that can take a long time, the bridge can avoid a Ruby-side **wait timeout** by
-scheduling the call and resuming in a **block** when the `RET` arrives.
+For R work that can take a long time **on the bridge**, the bridge can avoid a Ruby-side
+**wait timeout** by scheduling the call and resuming in a **block** when the `RET` arrives.
+
+**Important distinction:** this keeps the **same** GNU R process busy. Other sync
+`eval_r` / gknit chunks still wait on that R. For CRAN installs and other work that must
+**not** monopolize the bridge (or that can OOM a small VM if abandoned mid-compile), use
+**`R::Job`** in the next section instead.
 
 - **`R.eval_r_async(code, timeout: nil) { |result| ... }`** — string eval; on success, `result.value`
   is the same formatted string as **`R.eval_r`** (use `timeout: nil` for no Ruby-side limit).
@@ -514,6 +532,67 @@ the outcome to storage, and notify the client (poll, WebSocket, Turbo Stream, et
 Ruby pattern above is only to show **when** the result exists (inside the block, or after data
 written there is observed elsewhere). Runnable specs live in **`new_bridge_specs/eval_r_async_spec.rb`**.
 
+## Background R jobs (`R::Job`)
+
+`R::Async` / `R.eval_r_async` free the **Ruby** thread while the **same** bridge R process
+runs your code. That is enough for Rails-style “don’t block the request thread,” but not
+enough for heavy `install.packages` or multi-minute model fits: the gatekeeper R is still
+busy, other chunks time out, and abandoning the wait can leave compile work burning RAM.
+
+**`R::Job`** runs that work in a **child `Rscript` process**. The bridge stays free. Logs and
+metadata live under `~/.local/share/galaaz/jobs/` (override with `GALAAZ_JOBS_DIR`).
+
+### Package installs
+
+`R.install_and_loads` / `R.install_rlibs` use `R::Job.install` and **await until the child
+finishes** (default: no wall-clock limit). Optional limit: `GALAAZ_INSTALL_TIMEOUT_SEC` or
+`install_timeout_sec:`. On timeout the child process group is killed so leftover
+`make`/`gcc` cannot OOM the shell. Stale `00LOCK-*` dirs are cleared before the next install.
+Only one install runs at a time (`install.lock`).
+
+``` ruby
+# May take a long time the first time (e.g. caret); the bridge is not used for compile.
+R.install_and_loads 'caret'
+```
+
+### Long arbitrary R (`eval` / `script`)
+
+Prefer the **block** form (like `File.open`): await the child, yield the job, return the
+block’s value. Without a block, the methods still await by default and return the `Job`.
+
+``` ruby
+coef = R::Job.eval(<<~R) { |job| job.load_rds }
+  fit <- lm(mpg ~ wt, data = mtcars)
+  saveRDS(unname(coef(fit)), result_path)
+R
+puts coef
+```
+
+```
+## [1] 37.285126 -5.344472
+```
+
+``` ruby
+# Without a block: awaits (wait: true is the default) and returns the Job
+job = R::Job.eval(code)
+job = R::Job.eval(code, wait: false)  # start only; call job.wait later
+
+# Script file; trailing args → commandArgs(trailingOnly=TRUE) in the child
+res = R::Job.script('train.R', '5') { |job| job.load_rds }
+```
+
+In the child: `setwd(job.dir)`, `.libPaths` includes the Galaaz user library,
+`GALAAZ_JOB_DIR` is set, and **`result_path`** defaults to
+`file.path(GALAAZ_JOB_DIR, "result.rds")`. Persist with `saveRDS(..., result_path)`, then
+load on the bridge with **`job.load_rds`** (short sync `readRDS` → a normal Galaaz R object).
+
+### Choosing async vs Job
+
+| Need | Use |
+|------|-----|
+| Don’t freeze a Ruby thread; short/medium R on the bridge is OK | `R::Async` / `R.eval_r_async` |
+| Install CRAN packages, or long R that must not block the bridge | `R::Job` / `R.install_and_loads` |
+
 ## Galaaz + Rails (R-on-Rails) integration baseline
 
 This is the practical **R-on-Rails** starter: an R scientist’s analysis behind a small Rails
@@ -1873,7 +1952,8 @@ using even a very complex package as 'caret' is trivial with Galaaz.
 
 A word of advice: the 'caret' package has lots of dependencies and installing
 it in a Linux system is a time consuming operation.  Method 'R.install_and_loads'
-will install the package if it is not already installed and can take a while.
+will install the package if it is not already installed (via **`R::Job`**: a child
+`Rscript`, so the bridge stays free) and can take a while.
 
 ````
 ```{include model}
@@ -4194,10 +4274,11 @@ pulls in several dependencies; the first install can take several minutes.
 ## Example: DESeq2 on the airway dataset
 
 The script **`examples/bioconductor_deseq2_airway/deseq2_airway_galaaz.rb`** is the canonical
-version in the repository. Run it from the **Galaaz repository root** with JRuby, for example:
+version in the repository. Run it from the **Galaaz repository root** with either engine, for example:
 
 ```text
-bin/galaaz-jruby examples/bioconductor_deseq2_airway/deseq2_airway_galaaz.rb
+bin/galaaz-ruby examples/bioconductor_deseq2_airway/deseq2_airway_galaaz.rb
+# or: bin/galaaz-jruby examples/bioconductor_deseq2_airway/deseq2_airway_galaaz.rb
 ```
 
 The workflow in Ruby mirrors a standard DESeq2 vignette:
@@ -4226,7 +4307,7 @@ manual is knitted, because **DESeq2** is heavy and may be absent on the build ma
 
 ``` ruby
 # Canonical script: examples/bioconductor_deseq2_airway/deseq2_airway_galaaz.rb
-# Run: bin/galaaz-jruby examples/.../deseq2_airway_galaaz.rb (repo root).
+# Run: bin/galaaz-ruby examples/.../deseq2_airway_galaaz.rb (repo root).
 
 require 'galaaz'
 

data/bin/gknit

@@ -65,26 +65,22 @@ that are created during rendering.") do |opt|
   opts.on("--callback_timeout_ms TIMEOUT_MS", Integer, "Callback timeout in milliseconds for R<->Ruby calls inside chunk execution. Use for long installs/computation (e.g., 7200000 for 2h).") do |opt|
     options[:callback_timeout_ms] = opt
   end
-  opts.on("--bridge_timeout_sec TIMEOUT_SEC", Integer, "Bridge request timeout in seconds for Ruby->R eval calls (default 60). Increase for long install.packages/compilation work.") do |opt|
+  opts.on("--bridge_timeout_sec TIMEOUT_SEC", Integer, "Bridge request timeout in seconds for Ruby->R eval calls (default 60). For CRAN installs via R::Job, use GALAAZ_INSTALL_TIMEOUT_SEC instead.") do |opt|
     options[:bridge_timeout_sec] = opt
   end
+  opts.on("--install_timeout_sec TIMEOUT_SEC", Integer, "Await limit in seconds for R::Job package installs (sets GALAAZ_INSTALL_TIMEOUT_SEC). Default: wait until the child finishes.") do |opt|
+    options[:install_timeout_sec] = opt
+  end
 end
 
 remaining_args = parser.permute(ARGV.dup)
 ARGV.replace(remaining_args)
 
-# Sets the directory
-dir = Dir.pwd
-
-#=========================================================================================
-# Check if the name of the file to gKnit was given and that it exists. If not,
-# issue error.
-#=========================================================================================
-
 options[:input_file] = ARGV[0] if !ARGV[0].nil?
 raise "Input file name is required for gKnitting. Add -f FILE or --input_file FILE. For help, type gknit -h" if
   options[:input_file].nil?
-options[:input_file] = "#{dir}/#{options[:input_file]}"
+# File.expand_path keeps absolute paths intact (do not prefix Dir.pwd).
+options[:input_file] = File.expand_path(options[:input_file])
 raise "File #{options[:input_file]} does not exist!" if !File.exist?(options[:input_file])
 
 #=========================================================================================
@@ -153,6 +149,7 @@ input_dir = File.dirname(input_file)
 code = <<EOF
 ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = #{options[:callback_timeout_ms].to_s.inspect} if #{!options[:callback_timeout_ms].nil?}
 ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] = #{options[:bridge_timeout_sec].to_s.inspect} if #{!options[:bridge_timeout_sec].nil?}
+ENV['GALAAZ_INSTALL_TIMEOUT_SEC'] = #{options[:install_timeout_sec].to_s.inspect} if #{!options[:install_timeout_sec].nil?}
 require %q(galaaz)
 require %q(gknit)
 
@@ -199,6 +196,11 @@ Dir.chdir(#{input_dir.inspect}) do
       STDERR.puts "Likely bridge timeout during long-running Ruby->R evaluation."
       STDERR.puts "Current bridge timeout: \#{bridge_sec} sec; callback timeout: \#{callback_ms} ms."
       STDERR.puts "Use gknit --bridge_timeout_sec <sec> and/or --callback_timeout_ms <ms> for longer operations."
+    elsif e.message.to_s.match?(/install job timed out/i)
+      install_sec = ENV['GALAAZ_INSTALL_TIMEOUT_SEC'] || '(none - wait until done)'
+      STDERR.puts "Likely R::Job install await timeout."
+      STDERR.puts "Current GALAAZ_INSTALL_TIMEOUT_SEC: \#{install_sec}."
+      STDERR.puts "Use gknit --install_timeout_sec <sec> (or unset it to wait forever), or install the package outside gknit."
     end
     if missing_pkg
       STDERR.puts "Likely missing LaTeX package: \#{missing_pkg} (install with tlmgr)."
@@ -218,6 +220,7 @@ libx = File.expand_path('../lib', File.dirname(__FILE__))
 require File.join(libx, 'galaaz_ruby')
 ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = options[:callback_timeout_ms].to_s if !options[:callback_timeout_ms].nil?
 ENV['GALAAZ_BRIDGE_TIMEOUT_SEC'] = options[:bridge_timeout_sec].to_s if !options[:bridge_timeout_sec].nil?
+ENV['GALAAZ_INSTALL_TIMEOUT_SEC'] = options[:install_timeout_sec].to_s if !options[:install_timeout_sec].nil?
 exec "#{GalaazRuby.shell_invocation(libx)} -e #{Shellwords.escape(code)}"
 
 =begin

data/bin/gknit_Rscript

@@ -30,9 +30,6 @@ OptionParser.new do |opts|
   end
 end.parse!
 
-# Sets the directory
-dir = Dir.pwd
-
 #=========================================================================================
 # Check if the name of the file to gKnit was given and that it exists. If not,
 # issue error.
@@ -41,7 +38,8 @@ dir = Dir.pwd
 options[:input_file] = ARGV[0] if !ARGV[0].nil?
 raise "Input file name is required for gKnitting. Add -f FILE or --input_file FILE. For help, type gknit -h" if
   options[:input_file].nil?
-options[:input_file] = "#{dir}/#{options[:input_file]}"
+# File.expand_path keeps absolute paths intact (do not prefix Dir.pwd).
+options[:input_file] = File.expand_path(options[:input_file])
 raise "File #{options[:input_file]} does not exist!" if !File.exist?(options[:input_file])
 
 #=========================================================================================

data/bin/gstudio_irb.rb

@@ -1,36 +1,85 @@
+# frozen_string_literal: true
+
 require 'galaaz'
 require 'ggplot'
-require 'irb/completion'
 require 'pp'
+require 'irb'
+require 'reline'
 
-IRB.conf[:PROMPT][:CUSTOM] = {
-  :PROMPT_I => "galaaz >> ",
-  :PROMPT_S => "%l>> ",
-  :PROMPT_C => ".. ",
-  :PROMPT_N => ".. ",
-  :RETURN => "=> %s\n"
-}
+# --- terminal capability -------------------------------------------------------
 
-IRB.conf[:PROMPT_MODE] = :CUSTOM
+def gstudio_colorize?
+  return false unless ENV['NO_COLOR'].to_s.empty?
+  return false if ENV['TERM'].to_s == 'dumb'
+  true
+end
+
+def gstudio_version
+  spec = Gem.loaded_specs['galaaz']
+  return spec.version.to_s if spec
+
+  version_rb = File.expand_path('../../version.rb', __FILE__)
+  if File.file?(version_rb)
+    load version_rb
+    return $version.to_s if defined?($version) && $version
+  end
+
+  '?'
+end
+
+colorize = gstudio_colorize?
+dumb = ENV['TERM'].to_s == 'dumb'
+
+# --- modern IRB defaults (Ruby >= 3.1 / Reline) --------------------------------
+
+IRB.conf[:USE_MULTILINE] = !dumb
+IRB.conf[:USE_COLORIZE] = colorize
+IRB.conf[:USE_AUTOCOMPLETE] = !dumb
 IRB.conf[:AUTO_INDENT] = true
 IRB.conf[:SAVE_HISTORY] = 1000
-IRB.conf[:HISTORY_FILE] = '~/.galaaz.history'
+IRB.conf[:HISTORY_FILE] = File.expand_path('~/.galaaz.history')
+# R-like session: expression results are printed by Galaaz/R, not Ruby inspect.
 IRB.conf[:ECHO] = false
 
-# history command
-def history(count = 0)
+cyan = colorize ? "\e[36m" : ''
+bold = colorize ? "\e[1m" : ''
+reset = colorize ? "\e[0m" : ''
+
+IRB.conf[:PROMPT][:CUSTOM] = {
+  PROMPT_I: "#{bold}#{cyan}galaaz#{reset} >> ",
+  PROMPT_S: '%l>> ',
+  PROMPT_C: '.. ',
+  PROMPT_N: '.. ',
+  RETURN: "=> %s\n"
+}
+IRB.conf[:PROMPT_MODE] = :CUSTOM
+
+prior_rc = IRB.conf[:IRB_RC]
+IRB.conf[:IRB_RC] = lambda do |context|
+  prior_rc.call(context) if prior_rc.respond_to?(:call)
+  puts "Galaaz #{gstudio_version} on #{RUBY_ENGINE} #{RUBY_VERSION} " \
+       "(IRB #{IRB::VERSION}). Tab completes; `history` lists input."
+end
 
-  # Get history into an array
-  history_array = Readline::HISTORY.to_a
+# --- session helpers -----------------------------------------------------------
 
-  # if count is > 0 we'll use it.
-  # otherwise set it to 0
-  count = count > 0 ? count : 0
+module Kernel
+  # Print recent input lines. Optional +count+ limits to the last N entries.
+  def history(count = 0)
+    history_array =
+      if defined?(Reline::HISTORY)
+        Reline::HISTORY.to_a
+      elsif defined?(Readline::HISTORY)
+        Readline::HISTORY.to_a
+      else
+        []
+      end
 
-  if count > 0
-    from = hist.length - count
-    history_array = history_array[from..-1] 
-  end
+    if count.is_a?(Integer) && count > 0
+      history_array = history_array.last(count)
+    end
 
-  print history_array.join("\n")
+    puts history_array.join("\n")
+    nil
+  end
 end

data/blogs/README.md

@@ -95,6 +95,6 @@ GALAAZ_DEBUG_R=1 bin/run_example examples/sthda_ggplot/all.rb
 
 ## Requirements
 
-- **JRuby** (same as specs/examples).
+- **JRuby** or **CRuby** (same as specs/examples; use `bin/galaaz-ruby` / `GALAAZ_RUBY`).
 - **R** with packages used by the document (e.g. `rmarkdown`, `knitr`, `ggplot2`).
 - Run from the project root so `lib` and `bin` resolve correctly.

data/blogs/galaaz_ggplot/galaaz_ggplot.Rmd

@@ -1,8 +1,8 @@
 ---
 title: "Ruby Plotting with Galaaz"
-subtitle: "An example of tightly coupling Ruby and R (JRuby + GNU R, Galaaz 2.0)"
+subtitle: "An example of tightly coupling Ruby and R (JRuby or CRuby + GNU R, Galaaz 2.0)"
 author: "Rodrigo Botafogo"
-tags: [Galaaz, Ruby, R, JRuby, "GNU R", ggplot2]
+tags: [Galaaz, Ruby, R, JRuby, CRuby, "GNU R", ggplot2]
 date: "16 October 2018 (narrative updated for Galaaz 2.0, 2026)"
 output:
   html_document:
@@ -36,11 +36,11 @@ widely used examples among **many thousands** of packages on PyPI for numerical
 With Galaaz we do not intend to re-implement any of the scientific libraries in R; we allow
 for very tight coupling between the two languages to the point that the Ruby developer does
 not need to think about R syntax for every call. **Galaaz 2.0** does this with **[JRuby](https://www.jruby.org/)**
-and **GNU R**: a **bridge** evaluates R from Ruby and exchanges data between processes.
+or **CRuby** and **GNU R**: a **bridge** evaluates R from Ruby and exchanges data between processes.
 
 An **earlier** Galaaz prototype used Oracle’s **GraalVM** with **TruffleRuby** and **FastR** in one JVM.
-That stack is **historical**; today’s documentation and tooling assume **JRuby + GNU R** (see the
-project manual and **`bin/galaaz-jruby`** / **`bin/gknit`**).
+That stack is **historical**; today’s documentation and tooling assume **NewBridge on JRuby or CRuby**
+(see the project manual and **`bin/galaaz-ruby`** / **`bin/gknit`**).
 
 For background on the old stack:
 
@@ -68,7 +68,7 @@ Galaaz is the Portuguese name for "Galahad".  From Wikipedia:
 
 ## Prerequisites (Galaaz 2.0)
 
-* **JRuby** and a compatible **JDK**
+* **JRuby** and a compatible **JDK**, *or* **CRuby 3.3+**
 * **GNU R** on your `PATH`
 
 The following R packages will be automatically installed when necessary, but could be installed prior
@@ -334,5 +334,5 @@ nicely complement R packages.
 
 For the Ruby developer, Galaaz allows the immediate use of R functions with minimal ceremony. As
 shown in the second example above, class `ScatterPlot` hides most R call details from the Ruby
-developer. **JRuby** provides **real parallel threads** on the Ruby side and access to the JVM
-ecosystem when you need it.
+developer. Prefer **JRuby** when you want **real parallel threads** on the Ruby side and access to
+the JVM ecosystem; **CRuby** works equally for the Galaaz bridge itself.

data/blogs/galaaz_ggplot/galaaz_ggplot.md

@@ -12,13 +12,13 @@ With Galaaz we do not intend to re-implement any of the scientific
 libraries in R; we allow for very tight coupling between the two
 languages to the point that the Ruby developer does not need to think
 about R syntax for every call. **Galaaz 2.0** does this with
-**[JRuby](https://www.jruby.org/)** and **GNU R**: a **bridge**
+**[JRuby](https://www.jruby.org/)** or **CRuby** and **GNU R**: a **bridge**
 evaluates R from Ruby and exchanges data between processes.
 
 An **earlier** Galaaz prototype used Oracle’s **GraalVM** with
 **TruffleRuby** and **FastR** in one JVM. That stack is **historical**;
-today’s documentation and tooling assume **JRuby + GNU R** (see the
-project manual and **`bin/galaaz-jruby`** / **`bin/gknit`**).
+today’s documentation and tooling assume **NewBridge on JRuby or CRuby**
+(see the project manual and **`bin/galaaz-ruby`** / **`bin/gknit`**).
 
 For background on the old stack:
 
@@ -47,7 +47,7 @@ Galaaz is the Portuguese name for “Galahad”. From Wikipedia:
 
 ## Prerequisites (Galaaz 2.0)
 
-- **JRuby** and a compatible **JDK**
+- **JRuby** and a compatible **JDK**, *or* **CRuby 3.3+**
 - **GNU R** on your `PATH`
 
 The following R packages will be automatically installed when necessary,
@@ -360,5 +360,5 @@ nicely complement R packages.
 For the Ruby developer, Galaaz allows the immediate use of R functions
 with minimal ceremony. As shown in the second example above, class
 `ScatterPlot` hides most R call details from the Ruby developer.
-**JRuby** provides **real parallel threads** on the Ruby side and access
-to the JVM ecosystem when you need it.
+Prefer **JRuby** when you want **real parallel threads** on the Ruby side and access
+to the JVM ecosystem; **CRuby** works equally for the Galaaz bridge itself.

data/blogs/gknit/gknit.Rmd

@@ -3,7 +3,7 @@ title: "How to do reproducible research in Ruby with gKnit"
 author:
     - "Rodrigo Botafogo"
     - "Daniel Mossé - University of Pittsburgh"
-tags: [Tech, Data Science, Ruby, R, JRuby, "GNU R", Galaaz, gKnit, knitr]
+tags: [Tech, Data Science, Ruby, R, JRuby, CRuby, "GNU R", Galaaz, gKnit, knitr]
 date: "29/04/2019 (narrative updated for Galaaz 2.0, 2026)"
 bibliography: stats.bib
 output:
@@ -109,7 +109,7 @@ written both in Ruby and/or R and output it in any of the available formats of _
 allows ruby developers to do literate programming and reproducible research by allowing them to
 have in a single document, text and code.
 
-gKnit runs with **JRuby**, **GNU R**, and **Galaaz** (the integration layer between Ruby and R—see below).
+gKnit runs with **JRuby or CRuby**, **GNU R**, and **Galaaz** (the integration layer between Ruby and R—see below).
 Knitr and **R Markdown** orchestrate the document; Galaaz’s engine keeps **Ruby state across chunks**
 and talks to R through the **bridge**. Ruby chunks can read and update R variables (`~R[:name]`, `R.*`)
 without GraalVM-style polyglot interop.
@@ -139,7 +139,7 @@ title: "How to do reproducible research in Ruby with gKnit"
 author: 
     - "Rodrigo Botafogo"
     - "Daniel Mossé - University of Pittsburgh"
-tags: [Tech, Data Science, Ruby, R, JRuby, "GNU R", Galaaz]
+tags: [Tech, Data Science, Ruby, R, JRuby, CRuby, "GNU R", Galaaz]
 date: "20/02/2019"
 output:
   html_document:
@@ -610,7 +610,8 @@ using even a very complex package as 'caret' is trivial with Galaaz.
 
 A word of advice: the 'caret' package has lots of dependencies and installing
 it in a Linux system is a time consuming operation.  Method 'R.install_and_loads'
-will install the package if it is not already installed and can take a while.
+will install the package if it is not already installed (via **`R::Job`**: a child
+`Rscript`, so the bridge stays free) and can take a while.
 
 ````
 ```{include model}`r ''`
@@ -633,7 +634,7 @@ puts model.test.head
 gKnit also allows developers to document and load files that are not in the same directory
 of the '.Rmd' file.
 
-Here is an example of loading the 'find.rb' file from **JRuby** (via `$LOAD_PATH`). In this example, relative
+Here is an example of loading the 'find.rb' file from Ruby (via `$LOAD_PATH`). In this example, relative
 is set to FALSE, so Ruby will look for the file in its $LOAD\_PATH, and the user does not
 need to know its directory.
 
@@ -657,9 +658,9 @@ the Yaml header to generate this blog in PDF format instead of HTML:
 
 ```
 ---
-title: "gKnit - Ruby and R Knitting with Galaaz (JRuby + GNU R)"
+title: "gKnit - Ruby and R Knitting with Galaaz (JRuby or CRuby + GNU R)"
 author: "Rodrigo Botafogo"
-tags: [Galaaz, Ruby, R, JRuby, "GNU R", knitr, gknit]
+tags: [Galaaz, Ruby, R, JRuby, CRuby, "GNU R", knitr, gknit]
 date: "29 October 2018"
 output:
   pdf\_document:
@@ -682,13 +683,13 @@ be imported from files in the system.  Ideally, in reproducible research, all th
 needed to rebuild a report should be easily packed together (in the same zipped directory)
 and distributed to peers for reexecution.
 
-**Galaaz 2.0** pairs **JRuby** with **GNU R**: you keep the full CRAN/Bioconductor world in R while
+**Galaaz 2.0** pairs **JRuby or CRuby** with **GNU R**: you keep the full CRAN/Bioconductor world in R while
 writing orchestration, reuse, and application code in Ruby. The effort to wrap Ruby over R (Galaaz)
 and to wrap Knitr as gKnit was tiny compared to reimplementing R’s ecosystem in Ruby—much like
 Python’s investment in NumPy and Pandas, which no Ruby project is likely to duplicate.
 
 An **earlier** prototype used Oracle’s **GraalVM** and Truffle interop; the **current** stack is
-deliberately **standard GNU R** plus the Galaaz **bridge**, documented in the project manual.
+deliberately **standard GNU R** plus the Galaaz **bridge** on JRuby or CRuby, documented in the project manual.
 
 More interesting than wrapping the R libraries with Ruby, is that Ruby adds
 value to R, by allowing developers to use powerful and modern constructs for code reuse that
@@ -700,7 +701,7 @@ readability.
 
 ## Prerequisites (Galaaz 2.0)
 
-* **JRuby** and a compatible **JDK**
+* **JRuby** and a compatible **JDK**, *or* **CRuby 3.3+**
 * **GNU R** on your `PATH`
 
 The following R packages will be automatically installed when necessary, but could be installed prior
@@ -720,7 +721,7 @@ the usual build tools are typically enough.  On macOS, Xcode command-line tools
 ## Usage
 
 * **`bin/gknit`** \<filename\> (from the Galaaz repo or your install layout); use **`--output_format all`** for HTML and PDF together.
-* Run Ruby with **`bin/galaaz-jruby`** when you need the same JVM flags as the project (see the manual).
+* Run Ruby with **`bin/galaaz-ruby`** (either engine) or **`bin/galaaz-jruby`** when you need JRuby JVM flags (see the manual).
 
 
 # References