diff --git a/hugo.toml b/hugo.toml index e73aba7..a4c0927 100644 --- a/hugo.toml +++ b/hugo.toml @@ -15,7 +15,7 @@ disableKinds = ["taxonomy", "term", "RSS", "sitemap", "404"] blurb = "Classes, modules, inheritance, mutable method tables, `@ivars`, `new`/`initialize`, constants, `include` mixins, `super`, blocks & `yield`, `block_given?`, method_missing — the live object model that makes monkey-patching free." [[params.phases]] name = "Phase 2 — Core types & mixins" - status = "active" + status = "ready" blurb = "Integer (with **Bignum** promotion + arbitrary-precision literals, **radix literals** `0x`/`0o`/`0b`/`0d`, **bitwise/shift** `<< >> & | ^ ~`), Float, mutable String, Symbol (incl. **operator-method symbols** `:+`/`:<<`/`:[]=`), Array, ordered Hash, Range (incl. beginless/endless). Full argument system (optional/`*splat`/keyword/`**rest`/`&block`), Proc/lambda/stabby `->(){}`, `Symbol#to_proc`, class methods, `attr_accessor`, `Struct`. Comparable and Enumerable written once, in embedded Ruby." [[params.phases]] name = "Phase 3 — Control flow & Fiber" @@ -27,7 +27,7 @@ disableKinds = ["taxonomy", "term", "RSS", "sitemap", "404"] blurb = "`define_method`, `instance_eval`/`instance_exec`, `class_eval`/`module_eval`/`class_exec`, `send`/`public_send`, `respond_to?`, `instance_variable_get`/`set`/`defined?`, `tap`/`then`, the hooks `included`/`inherited`/`method_added`/`extended`, `define_singleton_method`/`extend` and `def obj.foo` syntax, **`@@class variables`**, **`$global variables`**, string `eval`, **`Binding`** (`binding`/`Binding#eval`/`eval(str, binding)` + `local_variable_get`/`set`/`local_variables`/`receiver` — eval against a captured frame's locals), and **`prepend`** with an ancestor-chain `super` (walks included/prepended modules and the singleton chain; `Module#ancestors`/`include?`, `Kernel` modelled)." [[params.phases]] name = "Phase 5 — Full front-end" - status = "active" + status = "ready" blurb = "Interpolation, keyword args, endless methods (`def foo = expr`), beginless/endless ranges, the stabby lambda, multiple assignment, full pattern matching `case/in` (value/bind/class/array/hash/find/pin/alternative, guards, one-line `=>`/`in`), safe navigation `&.`, numbered params (`_1`/`it`), modifier `rescue`, heredocs (`<<`/`<<-`/`<<~`, interpolating and literal), `%w`/`%i` arrays and the `%q`/`%Q`/`%W`/`%I` literals already landed." [[params.phases]] name = "Phase 6 — Standard library" @@ -40,4 +40,4 @@ disableKinds = ["taxonomy", "term", "RSS", "sitemap", "404"] [[params.phases]] name = "Phase 8 — Conformance & performance" status = "active" - blurb = "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** — **71 modules are now bound into rbgo as native modules** (parser, regexp, erb, marshal, yaml, format, optparse, strscan, json, set, date, … the full list is on the landing page), out of **104 CI-green family libraries** overall (binding the rest in progress), each its own 100%-coverage 6-arch org. Every one of the six arches is validated on **real hardware**, not just qemu — amd64/arm64 natively, riscv64/ppc64le/loong64 on the GCC Compile Farm (RVV, POWER8E/POWER9, LoongArch), s390x on the IBM LinuxONE Community Cloud — which is what makes the SIMD-accelerated modules and perf numbers measured rather than estimated. On performance, a 6-runtime suite (rbgo/rbgo+AOT vs MRI/YJIT/JRuby/TruffleRuby): **rbgo+AOT beats MRI+YJIT 18–24× on loop/fib**; 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: **21,982 examples pass** (measured 2026-09-23 on `main`, `d498ddc`, four consecutive runs all identical), gated in CI by a **shrink-only floor of 21,970** — the floor is the level CI refuses to fall below, *not* the score. It sits just under the measured total by design: a margin wide enough for the run-to-run jitter, narrow enough that losing a whole spec file still trips it. It has climbed from 6,000 when the ratchet landed on 2026-08-03, across 27 waves. 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.) Every one of the six arches is validated on **real hardware**, not just qemu — amd64/arm64 natively, riscv64/ppc64le/loong64 on the GCC Compile Farm (RVV, POWER8E/POWER9, LoongArch), s390x on the IBM LinuxONE Community Cloud — which is what makes the SIMD-accelerated modules and perf numbers measured rather than estimated. On performance, a 6-runtime suite (rbgo/rbgo+AOT vs MRI/YJIT/JRuby/TruffleRuby): **rbgo+AOT beats MRI+YJIT 18–24× on loop/fib**; 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/_default/list.html b/layouts/_default/list.html index 73b0495..c5473bc 100644 --- a/layouts/_default/list.html +++ b/layouts/_default/list.html @@ -67,8 +67,17 @@
The pure-Go front-end and runtime, tested against real-world Ruby applications — parse, parse + compile, and end-to-end execution.
~100% of all valid Ruby parsed across Rails + Puppet — 99.96% of files; the 2 misses are syntax-error fixtures MRI itself rejects.
+21,982 examples pass in ruby/spec's language/ + core/ suites, measured 2026-09-23 on main (d498ddc), four consecutive runs all identical.
~100% of all valid Ruby parsed across Rails + Puppet — 99.96% of files; the 2 misses are syntax-error fixtures MRI itself rejects. Not re-measured since.
A real object model — classes, mixins, method_missing, metaprogramming, Fiber — callable straight from Go.
CGO=0 by default. Cross-compiles to amd64, arm64, riscv64, loong64, ppc64le and s390x.
Ahead-of-time method compilation to unboxed Go kernels — 18–24× over MRI+YJIT on loop/fib.
~100% of valid Ruby parsed across Rails + Puppet; parse+compile 99.82% / 100%, zero over-permissive.
21,982 ruby/spec language/ + core/ examples pass, gated in CI by a shrink-only floor of 21,970 — the floor is what CI refuses to fall below, not the score. It sits just under the measured total by design: a margin wide enough for run-to-run jitter, narrow enough that losing a whole spec file still trips it. Front-end: ~100% of valid Ruby parsed across Rails + Puppet (2026-06).
rbgo build --closed bakes the program to bytecode and drops the front-end for a smaller binary.
Built from the go-ruby-* family — each a 100%-coverage, 6-arch stdlib module, bound natively.