From cdd171b776a7ffb154594b3d02e0cbfd887a903e Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sat, 31 Oct 2026 21:51:02 +0100 Subject: [PATCH 1/3] say which Ruby version the 23,511 was counted at MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This page states the ruby/spec total five times and never said which population it counts over. The shim resolves ruby/spec's own `ruby_version_is` guards at Ruby 3.4.1, so every example behind a `ruby_version_is "4.0"` guard is removed from the suite before anything runs — 61 block guards and 5 inline sites at that boundary (censused by the interpreter repo's `cmd/guards`), and 41 guards asserting what 4.0 changed away from. Meanwhile the same page says the project targets Ruby 4.0 semantics and names an MRI 4.0.5 oracle. Every one of those statements is true, and together they read as a 4.0 result. It is a 3.4-shaped one. Two sentences, in the two places that carry the figure most plainly: the "Conformance, measured" card, beside the existing caveat that only `language/` and `core/` are swept — the same kind of caveat, and it was missing its pair — and the Phase 8 blurb in hugo.toml, which already explains the gate at length. Measured with the tool that will enforce it: $ go run ./tools/conformancefigure --root 5 total claim(s) and 2 version claim(s) checked against the gate's 23511 at Ruby 3.4.1 (two copies, agreeing) Both new sentences are recognised and agree. "two copies, agreeing" is the state of the interpreter repository today: the version is spelled in both internal/vm/kernel_introspect.go and the conformance shim, and go-embedded-ruby/ruby#845 collapses that to one — at which point the same line will read "derived from RUBY_VERSION" without anything here changing. The lane bump to the version of the tool that performs this check comes in the next commit, once that release exists; stating the version without the check would be the unguarded half of the change. Co-Authored-By: Claude Opus 5 --- hugo.toml | 2 +- layouts/index.html | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/hugo.toml b/hugo.toml index ed9fd02..60baf8a 100644 --- a/hugo.toml +++ b/hugo.toml @@ -71,4 +71,4 @@ disableKinds = ["taxonomy", "term", "RSS", "sitemap", "404"] [[params.phases]] name = "Phase 8 — Conformance & performance" status = "active" - blurb = "Since July the work has been **runtime** conformance, measured against [ruby/spec](https://github.com/ruby/spec)'s `language/` + `core/` suites: **23,511 examples pass** — the total that `BASELINE` sums to on `main` (2026-10-30; 2,202 of 2,206 spec files produce a result, the other 4 recorded as FILEFAIL), gated in CI by a **per-file baseline** — one record per spec file, so a file that regresses is named rather than absorbed. It replaced a single shrink-only floor, which needed a margin wider than the largest spec file and was therefore blind to any regression smaller than that: the floor had climbed from 6,000 when the ratchet first landed on 2026-08-03 to 22,475, while sitting 211 below the measured total. **Only `language/` and `core/` are swept** — ruby/spec's `library/`, `optional/` and `security/` trees are not run at all, so this is not a percentage of Ruby. Two of the recent jumps were fixes to the **measurement** rather than the interpreter — the mspec shim, and a parser upgrade that made 13 previously-unparseable spec files visible — and those are gains in what the measurement can *see*, not in what the VM can *do*. Earlier, a conformance campaign brought the pure-Go **front-end** to ~**100% of all valid Ruby** parsed across Rails + Puppet (99.96% of files; 2 misses are syntax-error fixtures MRI rejects) and **parse + compile** of **Rails 99.82% / Puppet 100%**, with **0 over-permissive** — and RuboCop 99.7%, Sinatra/Jekyll/Thor/Kramdown/dry-struct 100%, RSpec DSL 10/10. On the runtime side, that road is now underway: **the real `puppet apply` CLI runs end-to-end** on a pure-Go CGO=0 `rbgo` — `require \"puppet\"` boots Puppet 8.11.0 (all pure-Ruby gem deps on the path), and the genuine `Puppet::Util::CommandLine` → `Puppet::Application::Apply` path (real `OptionParser`, all types + providers, settings catalog applied to disk, then the user catalog via the transaction/RAL) converges `notify`, `file` and `exec` resources (the `exec` provider runs commands via pure-Go process execution with `onlyif`/`unless`/`creates`/`path` guards), emits real Puppet output (`Notice: hi from rbgo cli`) and exits 0 with the YAML run report round-tripped. Broader resource **providers** are the active next milestone (`user`/`group` provider-ready; `package`/`service` need a host package manager/systemd + root). rbgo is also increasingly composed from the standalone pure-Go **go-ruby-* family** — **178 modules across 176 orgs are now bound into rbgo as native modules** (parser, regexp, erb, marshal, yaml, format, optparse, strscan, json, date, … a selection is on the landing page), each its own 100%-coverage 6-arch org. (`Set` is not among them: it is implemented in-tree, over rbgo's own Hash.) Of the six 64-bit arches, amd64 and arm64 are tested on every pull request, as is 32-bit 386 (since v0.8.2; 32-bit arm runs nightly under qemu), and since v0.8.3 every pull request also compiles rbgo for every GOOS/GOARCH Go supports except plan9; riscv64, loong64, ppc64le and s390x are validated on a **nightly schedule** — under qemu, and natively on the GCC Compile Farm plus an IBM LinuxONE s390x host — not on the pull-request path. On performance, a 6-runtime suite (rbgo/rbgo+AOT vs MRI/YJIT/JRuby/TruffleRuby): **rbgo+AOT beats MRI+YJIT on integer-bound kernels — measured here at 8.7× on the tight-loop benchmark and 2.0× on recursive `fib(35)`** (darwin/arm64, whole-process wall time); plus inline method caches, small-integer interning (a small-int loop drops from ~245k allocations to 1) and capture-tracked frame recycling (~14% faster on fib)." + blurb = "Since July the work has been **runtime** conformance, measured against [ruby/spec](https://github.com/ruby/spec)'s `language/` + `core/` suites: **23,511 examples pass** — the total that `BASELINE` sums to on `main` (2026-10-30; 2,202 of 2,206 spec files produce a result, the other 4 recorded as FILEFAIL), gated in CI by a **per-file baseline** — one record per spec file, so a file that regresses is named rather than absorbed. That count is taken with ruby/spec's own version guards set to resolve at Ruby **3.4.1**, the version this runtime reports, so it describes 3.4-shaped behaviour even though the target is 4.0 semantics: 61 block guards and 5 inline sites sit at the `ruby_version_is "4.0"` boundary and are removed from the suite before anything runs. It replaced a single shrink-only floor, which needed a margin wider than the largest spec file and was therefore blind to any regression smaller than that: the floor had climbed from 6,000 when the ratchet first landed on 2026-08-03 to 22,475, while sitting 211 below the measured total. **Only `language/` and `core/` are swept** — ruby/spec's `library/`, `optional/` and `security/` trees are not run at all, so this is not a percentage of Ruby. Two of the recent jumps were fixes to the **measurement** rather than the interpreter — the mspec shim, and a parser upgrade that made 13 previously-unparseable spec files visible — and those are gains in what the measurement can *see*, not in what the VM can *do*. Earlier, a conformance campaign brought the pure-Go **front-end** to ~**100% of all valid Ruby** parsed across Rails + Puppet (99.96% of files; 2 misses are syntax-error fixtures MRI rejects) and **parse + compile** of **Rails 99.82% / Puppet 100%**, with **0 over-permissive** — and RuboCop 99.7%, Sinatra/Jekyll/Thor/Kramdown/dry-struct 100%, RSpec DSL 10/10. On the runtime side, that road is now underway: **the real `puppet apply` CLI runs end-to-end** on a pure-Go CGO=0 `rbgo` — `require \"puppet\"` boots Puppet 8.11.0 (all pure-Ruby gem deps on the path), and the genuine `Puppet::Util::CommandLine` → `Puppet::Application::Apply` path (real `OptionParser`, all types + providers, settings catalog applied to disk, then the user catalog via the transaction/RAL) converges `notify`, `file` and `exec` resources (the `exec` provider runs commands via pure-Go process execution with `onlyif`/`unless`/`creates`/`path` guards), emits real Puppet output (`Notice: hi from rbgo cli`) and exits 0 with the YAML run report round-tripped. Broader resource **providers** are the active next milestone (`user`/`group` provider-ready; `package`/`service` need a host package manager/systemd + root). rbgo is also increasingly composed from the standalone pure-Go **go-ruby-* family** — **178 modules across 176 orgs are now bound into rbgo as native modules** (parser, regexp, erb, marshal, yaml, format, optparse, strscan, json, date, … a selection is on the landing page), each its own 100%-coverage 6-arch org. (`Set` is not among them: it is implemented in-tree, over rbgo's own Hash.) Of the six 64-bit arches, amd64 and arm64 are tested on every pull request, as is 32-bit 386 (since v0.8.2; 32-bit arm runs nightly under qemu), and since v0.8.3 every pull request also compiles rbgo for every GOOS/GOARCH Go supports except plan9; riscv64, loong64, ppc64le and s390x are validated on a **nightly schedule** — under qemu, and natively on the GCC Compile Farm plus an IBM LinuxONE s390x host — not on the pull-request path. On performance, a 6-runtime suite (rbgo/rbgo+AOT vs MRI/YJIT/JRuby/TruffleRuby): **rbgo+AOT beats MRI+YJIT on integer-bound kernels — measured here at 8.7× on the tight-loop benchmark and 2.0× on recursive `fib(35)`** (darwin/arm64, whole-process wall time); plus inline method caches, small-integer interning (a small-int loop drops from ~245k allocations to 1) and capture-tracked frame recycling (~14% faster on fib)." diff --git a/layouts/index.html b/layouts/index.html index ea038c4..dac3e02 100644 --- a/layouts/index.html +++ b/layouts/index.html @@ -59,7 +59,7 @@

Everything a Ruby runtime gives you — as a Go library.

🧩

Embeddable

A real object model — classes, mixins, method_missing, metaprogramming, Fiber. The Go API is deliberately small today: ruby.Run(src, out) runs a program on a fresh VM and writes its output to one writer. Calling a Ruby method from Go is not exposed yet.

📦

One static binary

CGO=0 by default. Tested on amd64, arm64, riscv64, loong64, ppc64le, s390x, 386 and arm; compiles for every GOOS/GOARCH Go supports except plan9 — 44 targets, the BSDs, AIX, Solaris and mips included.

⚡

AOT for integer kernels

Ahead-of-time compilation of integer-bound methods to unboxed Go. Measured on this project’s own micro-benchmarks (darwin/arm64, whole-process wall time): 8.7× MRI+YJIT on the tight-loop case, 2.0× on recursive fib(35). Only methods the compiler can lower benefit.

-
✅

Conformance, measured

23,511 ruby/spec language/ + core/ examples pass, gated in CI file by file: no spec file may pass fewer examples than its recorded row, so a regression is named rather than absorbed in a total. Only language/ and core/ are swept: library/, optional/ and security/ are not run, so this is not a percentage of Ruby. Front-end: ~100% of valid Ruby parsed across Rails + Puppet (2026-06).

+
✅

Conformance, measured

23,511 ruby/spec language/ + core/ examples pass, gated in CI file by file: no spec file may pass fewer examples than its recorded row, so a regression is named rather than absorbed in a total. Only language/ and core/ are swept: library/, optional/ and security/ are not run, so this is not a percentage of Ruby. Those guards resolve at Ruby 3.4.1 — the version this runtime reports — so every example behind a ruby_version_is "4.0" guard is removed from the suite before anything is counted: 61 block guards and 5 inline sites sit at that boundary, while the latest MRI release is 4.0.9. Front-end: ~100% of valid Ruby parsed across Rails + Puppet (2026-06).

🔒

Closed-world builds

rbgo build --closed bakes the program to bytecode and drops the front-end for a smaller binary.

🌿

A real ecosystem

Built from the go-ruby-* family — each a 100%-coverage, 6-arch stdlib module, bound natively.

From 47f7504696ed03fdc7a9260fb61039867bf2a126 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sat, 31 Oct 2026 23:21:07 +0100 Subject: [PATCH 2/3] conformancefigure@v0.6.0: turn the stated version into a checked claim MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The previous commit added the sentences; this is the half that makes them guarded, and neither is worth having alone — a version stated and unchecked is the next figure to rot, and a check with nothing to check exits 1. Verified with the exact published command this lane will run, fetched through the proxy: $ go run github.com/go-embedded-ruby/docs/tools/conformancefigure@v0.6.0 --root . go: downloading github.com/go-embedded-ruby/docs v0.6.0 5 total claim(s) and 2 version claim(s) checked against the gate's 23511 at Ruby 3.4.1 (two copies, agreeing) Five totals and both new version sentences, all agreeing. actionlint clean. The version is read from **both** files in the interpreter repository that spell it — `internal/vm/kernel_introspect.go`'s `rubyVersion` and the conformance shim's `CUR_VERSION` — and a disagreement between them is a refusal (exit 2), not a verdict on this page: with the copies apart there is no single version to judge it against. go-embedded-ruby/ruby#799 records that those are two hardcoded copies of one fact and that "today they happen to agree" is the defect waiting to happen. `(two copies, agreeing)` is that repository's state today. ruby#845 collapses it to one, and the same line will then read `(derived from RUBY_VERSION)` with nothing here to change — v0.6.0 already recognises that spelling, so this lane does not break on the day the thing it reports gets fixed. The **differential oracle** this page names (MRI 4.0.5) is a different claim, free to be newer than the version guards resolve at, and is deliberately not matched; three real oracle sentences are negative cases in the tool's own vocabulary control. Co-Authored-By: Claude Opus 5 --- .github/workflows/deploy-pages.yml | 30 ++++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/.github/workflows/deploy-pages.yml b/.github/workflows/deploy-pages.yml index 591eb2a..25ac87f 100644 --- a/.github/workflows/deploy-pages.yml +++ b/.github/workflows/deploy-pages.yml @@ -98,8 +98,34 @@ jobs: # because neither the tool's `.md`/`.html` filter nor this root could # reach it. v0.5.0 reads .toml; widening the root is what puts the third # copy in the denominator. It checks 5 claims now, not 4. - - name: The stated conformance total matches rbgo's gate - run: go run github.com/go-embedded-ruby/docs/tools/conformancefigure@v0.5.0 --root . + # + # ⛔ v0.6.0 ALSO CHECKS THE VERSION THE TOTAL WAS COUNTED AT, which is why + # this page now states it. `23,511 examples pass` is a count over a + # POPULATION, and the population is selected by the Ruby version the + # conformance shim resolves `ruby_version_is` guards at: at 3.4.1 every + # example behind a `ruby_version_is "4.0"` guard is removed from the suite + # before anything runs -- 61 block guards and 5 inline sites at that + # boundary -- so the figure describes 3.4-shaped behaviour while this page + # also says the project targets 4.0 semantics and names a 4.0.5 oracle. + # All true, and together they read as a 4.0 result. + # + # The version is read from BOTH files in the interpreter repository that + # spell it (`rubyVersion` and the shim's `CUR_VERSION`) and a disagreement + # between them is a refusal, not a verdict on this page. The DIFFERENTIAL + # ORACLE named here is a different claim, free to be newer, and is + # deliberately not matched. + # + # Verified with the exact published command this lane runs, fetched + # through the proxy: + # + # $ go run github.com/go-embedded-ruby/docs/tools/conformancefigure@v0.6.0 --root . + # 5 total claim(s) and 2 version claim(s) checked against the gate's 23511 at Ruby 3.4.1 (two copies, agreeing) + # + # "two copies, agreeing" is the interpreter repository's state today; + # go-embedded-ruby/ruby#845 collapses it to one and the same line will + # then read "derived from RUBY_VERSION", with nothing here to change. + - name: The stated conformance total, and the version it was counted at, match rbgo's gate + run: go run github.com/go-embedded-ruby/docs/tools/conformancefigure@v0.6.0 --root . - name: Build landing page run: hugo --minify --baseURL "${{ steps.pages.outputs.base_url }}/" From 5833d908653af08a43a9db9479f011981e988a42 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sat, 31 Oct 2026 23:40:03 +0100 Subject: [PATCH 3/3] =?UTF-8?q?hugo.toml:=20withdraw=20the=20sentence=20?= =?UTF-8?q?=E2=80=94=20that=20blurb's=20body=20is=20never=20published?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two things, one of them a correction to what I wrote in the previous commit. ## The build lane was right, and it caught what my own check cannot The push before this one broke the site: ERROR failed to load config: "hugo.toml:74:713": unmarshal failed: toml: expected newline but got U+0034 '4' My sentence contained `` `ruby_version_is "4.0"` `` — double quotes inside a double-quoted TOML string, unescaped. Mine, straightforwardly. Worth recording is **why `conformancefigure` was green on it**: that tool reads `.toml` as TEXT, looking for figures in prose, and never parses it. A file that cannot load is invisible to it, and always will be. `hugo --minify` is the check for that and it did its job on the first push. What I should have done, and had no excuse not to — hugo is installed here — is build the site locally before pushing. Doing that now: `hugo` exits 0. ## ⛔ And then the build showed the sentence was never going to be read With the quotes escaped and the site building, the rendered page did not contain it. Nor does it contain anything else from deep in that blurb: | in the built site | | |---|---| | the Phase 8 blurb's **first sentence** | present | | `LinuxONE` (pre-existing, deep in the same blurb) | **absent** | | my new sentence (also deep in it) | **absent** | | the sentence I added to `layouts/index.html` | present | The site builds two pages (`index.html`, `performance/index.html`) and the string appears in neither. **Everything in a `params.phases[].blurb` after its first sentence is unpublished** — the home page takes the first sentence for its card and nothing else renders the rest. So the sentence is withdrawn rather than escaped. A guard reporting *"2 version claim(s) checked"* while the page publishes **one** is a measurement flattering itself, which is the exact failure this whole change exists to prevent. After this commit the tool reports `1 version claim(s)` and the page publishes 1 — the numbers agree because they are counting the same thing. The claim is still guarded where it is read: `layouts/index.html`, in the "Conformance, measured" card, beside the existing caveat that only `language/` and `core/` are swept. ## ⛔ Correcting the previous commit and go-embedded-ruby/docs#41 I wrote that `hugo.toml`'s `params.phases[].blurb` is *"prose Hugo renders into the page like any other"* and that the stale `23,481` in it *"read 23,481 for 26 days under a green check"*. **The first is wrong for this site's layout, and the second is therefore overstated.** That figure was stale in a file that feeds only a first sentence; it was not a wrong number on the published page, and the published figures were correct throughout. What stands: the figure WAS stale in the repository, two readings of one number had drifted, and a tool that reads `.toml` is cheap insurance for the day a layout change starts publishing that text. What does not stand is the severity I gave it. Separately worth deciding, and not decided here: a long prose body kept in `hugo.toml` that nothing renders is a trap — it cost me this round trip, and it will cost the next person the same. Either it should be rendered or it should be deleted. Filed rather than guessed at. Co-Authored-By: Claude Opus 5 --- hugo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hugo.toml b/hugo.toml index 60baf8a..ed9fd02 100644 --- a/hugo.toml +++ b/hugo.toml @@ -71,4 +71,4 @@ disableKinds = ["taxonomy", "term", "RSS", "sitemap", "404"] [[params.phases]] name = "Phase 8 — Conformance & performance" status = "active" - blurb = "Since July the work has been **runtime** conformance, measured against [ruby/spec](https://github.com/ruby/spec)'s `language/` + `core/` suites: **23,511 examples pass** — the total that `BASELINE` sums to on `main` (2026-10-30; 2,202 of 2,206 spec files produce a result, the other 4 recorded as FILEFAIL), gated in CI by a **per-file baseline** — one record per spec file, so a file that regresses is named rather than absorbed. That count is taken with ruby/spec's own version guards set to resolve at Ruby **3.4.1**, the version this runtime reports, so it describes 3.4-shaped behaviour even though the target is 4.0 semantics: 61 block guards and 5 inline sites sit at the `ruby_version_is "4.0"` boundary and are removed from the suite before anything runs. It replaced a single shrink-only floor, which needed a margin wider than the largest spec file and was therefore blind to any regression smaller than that: the floor had climbed from 6,000 when the ratchet first landed on 2026-08-03 to 22,475, while sitting 211 below the measured total. **Only `language/` and `core/` are swept** — ruby/spec's `library/`, `optional/` and `security/` trees are not run at all, so this is not a percentage of Ruby. Two of the recent jumps were fixes to the **measurement** rather than the interpreter — the mspec shim, and a parser upgrade that made 13 previously-unparseable spec files visible — and those are gains in what the measurement can *see*, not in what the VM can *do*. Earlier, a conformance campaign brought the pure-Go **front-end** to ~**100% of all valid Ruby** parsed across Rails + Puppet (99.96% of files; 2 misses are syntax-error fixtures MRI rejects) and **parse + compile** of **Rails 99.82% / Puppet 100%**, with **0 over-permissive** — and RuboCop 99.7%, Sinatra/Jekyll/Thor/Kramdown/dry-struct 100%, RSpec DSL 10/10. On the runtime side, that road is now underway: **the real `puppet apply` CLI runs end-to-end** on a pure-Go CGO=0 `rbgo` — `require \"puppet\"` boots Puppet 8.11.0 (all pure-Ruby gem deps on the path), and the genuine `Puppet::Util::CommandLine` → `Puppet::Application::Apply` path (real `OptionParser`, all types + providers, settings catalog applied to disk, then the user catalog via the transaction/RAL) converges `notify`, `file` and `exec` resources (the `exec` provider runs commands via pure-Go process execution with `onlyif`/`unless`/`creates`/`path` guards), emits real Puppet output (`Notice: hi from rbgo cli`) and exits 0 with the YAML run report round-tripped. Broader resource **providers** are the active next milestone (`user`/`group` provider-ready; `package`/`service` need a host package manager/systemd + root). rbgo is also increasingly composed from the standalone pure-Go **go-ruby-* family** — **178 modules across 176 orgs are now bound into rbgo as native modules** (parser, regexp, erb, marshal, yaml, format, optparse, strscan, json, date, … a selection is on the landing page), each its own 100%-coverage 6-arch org. (`Set` is not among them: it is implemented in-tree, over rbgo's own Hash.) Of the six 64-bit arches, amd64 and arm64 are tested on every pull request, as is 32-bit 386 (since v0.8.2; 32-bit arm runs nightly under qemu), and since v0.8.3 every pull request also compiles rbgo for every GOOS/GOARCH Go supports except plan9; riscv64, loong64, ppc64le and s390x are validated on a **nightly schedule** — under qemu, and natively on the GCC Compile Farm plus an IBM LinuxONE s390x host — not on the pull-request path. On performance, a 6-runtime suite (rbgo/rbgo+AOT vs MRI/YJIT/JRuby/TruffleRuby): **rbgo+AOT beats MRI+YJIT on integer-bound kernels — measured here at 8.7× on the tight-loop benchmark and 2.0× on recursive `fib(35)`** (darwin/arm64, whole-process wall time); plus inline method caches, small-integer interning (a small-int loop drops from ~245k allocations to 1) and capture-tracked frame recycling (~14% faster on fib)." + blurb = "Since July the work has been **runtime** conformance, measured against [ruby/spec](https://github.com/ruby/spec)'s `language/` + `core/` suites: **23,511 examples pass** — the total that `BASELINE` sums to on `main` (2026-10-30; 2,202 of 2,206 spec files produce a result, the other 4 recorded as FILEFAIL), gated in CI by a **per-file baseline** — one record per spec file, so a file that regresses is named rather than absorbed. It replaced a single shrink-only floor, which needed a margin wider than the largest spec file and was therefore blind to any regression smaller than that: the floor had climbed from 6,000 when the ratchet first landed on 2026-08-03 to 22,475, while sitting 211 below the measured total. **Only `language/` and `core/` are swept** — ruby/spec's `library/`, `optional/` and `security/` trees are not run at all, so this is not a percentage of Ruby. Two of the recent jumps were fixes to the **measurement** rather than the interpreter — the mspec shim, and a parser upgrade that made 13 previously-unparseable spec files visible — and those are gains in what the measurement can *see*, not in what the VM can *do*. Earlier, a conformance campaign brought the pure-Go **front-end** to ~**100% of all valid Ruby** parsed across Rails + Puppet (99.96% of files; 2 misses are syntax-error fixtures MRI rejects) and **parse + compile** of **Rails 99.82% / Puppet 100%**, with **0 over-permissive** — and RuboCop 99.7%, Sinatra/Jekyll/Thor/Kramdown/dry-struct 100%, RSpec DSL 10/10. On the runtime side, that road is now underway: **the real `puppet apply` CLI runs end-to-end** on a pure-Go CGO=0 `rbgo` — `require \"puppet\"` boots Puppet 8.11.0 (all pure-Ruby gem deps on the path), and the genuine `Puppet::Util::CommandLine` → `Puppet::Application::Apply` path (real `OptionParser`, all types + providers, settings catalog applied to disk, then the user catalog via the transaction/RAL) converges `notify`, `file` and `exec` resources (the `exec` provider runs commands via pure-Go process execution with `onlyif`/`unless`/`creates`/`path` guards), emits real Puppet output (`Notice: hi from rbgo cli`) and exits 0 with the YAML run report round-tripped. Broader resource **providers** are the active next milestone (`user`/`group` provider-ready; `package`/`service` need a host package manager/systemd + root). rbgo is also increasingly composed from the standalone pure-Go **go-ruby-* family** — **178 modules across 176 orgs are now bound into rbgo as native modules** (parser, regexp, erb, marshal, yaml, format, optparse, strscan, json, date, … a selection is on the landing page), each its own 100%-coverage 6-arch org. (`Set` is not among them: it is implemented in-tree, over rbgo's own Hash.) Of the six 64-bit arches, amd64 and arm64 are tested on every pull request, as is 32-bit 386 (since v0.8.2; 32-bit arm runs nightly under qemu), and since v0.8.3 every pull request also compiles rbgo for every GOOS/GOARCH Go supports except plan9; riscv64, loong64, ppc64le and s390x are validated on a **nightly schedule** — under qemu, and natively on the GCC Compile Farm plus an IBM LinuxONE s390x host — not on the pull-request path. On performance, a 6-runtime suite (rbgo/rbgo+AOT vs MRI/YJIT/JRuby/TruffleRuby): **rbgo+AOT beats MRI+YJIT on integer-bound kernels — measured here at 8.7× on the tight-loop benchmark and 2.0× on recursive `fib(35)`** (darwin/arm64, whole-process wall time); plus inline method caches, small-integer interning (a small-int loop drops from ~245k allocations to 1) and capture-tracked frame recycling (~14% faster on fib)."