From 114bd3d2b0e8fc625a39c8791298bf2e090f303f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20V=C3=A1squez?= <juan@ombulabs.com>
Date: Tue, 6 Oct 2026 13:43:36 -0600
Subject: [PATCH 1/6] Step 1: Run every build on one machine, with the
 reference in between

The results site can only compare idioms inside one Ruby today: each Ruby
runs as its own CI job on its own machine, so i/s across Rubies is mostly
the machine. script/run_cross_ruby.rb runs every build of a shard's files
on one machine, one after the other, so their i/s can be compared.

The builds come from the rake matrix in benchmarks.yml, so a Ruby added to
CI is measured here too. The newest released MRI is the reference: it runs
first, again after every 3 builds, and last. It is the same code every
time, so its passes show how steady the machine was during the run.

A Ruby's interpreter and JIT builds run back to back, so each image is
fetched once and removed after its last pass (with --fresh-images, in CI),
which keeps the runner's disk free.

The collector records the shard, the pass, whether it is the reference and
when each report finished; those fields are empty for the regular CI jobs.
---
 compose.yaml              |   5 ++
 docker/collect_results.rb |   7 ++
 script/run_cross_ruby.rb  | 157 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 169 insertions(+)
 create mode 100644 script/run_cross_ruby.rb

diff --git a/compose.yaml b/compose.yaml
index 224c282..24723c4 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -21,6 +21,11 @@ x-benchmark: &benchmark
     - RESULTS_LABEL
     - RESULTS_COMMIT
     - RESULTS_PR
+    # Cross-Ruby runs only (script/run_cross_ruby.rb).
+    - RESULTS_SHARD
+    - RESULTS_SHARDS
+    - RESULTS_PASS
+    - RESULTS_REFERENCE
     - GITHUB_RUN_ID
     - GITHUB_RUN_ATTEMPT
     - RUNNER_NAME
diff --git a/docker/collect_results.rb b/docker/collect_results.rb
index 00ee82e..9d642fc 100644
--- a/docker/collect_results.rb
+++ b/docker/collect_results.rb
@@ -52,6 +52,13 @@ def write(report)
         "run_id" => env("GITHUB_RUN_ID"),
         "run_attempt" => env("GITHUB_RUN_ATTEMPT"),
         "runner" => env("RUNNER_NAME"),
+        # Set by script/run_cross_ruby.rb, which runs every build on one machine and the reference build between them; nil otherwise.
+        "shard" => env("RESULTS_SHARD") && env("RESULTS_SHARD").to_i,
+        "shards" => env("RESULTS_SHARDS") && env("RESULTS_SHARDS").to_i,
+        "pass" => env("RESULTS_PASS") && env("RESULTS_PASS").to_i,
+        "reference" => env("RESULTS_REFERENCE") == "1",
+        # When this report finished, to place it between the reference passes.
+        "measured_at" => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
         "environment" => environment,
         "entries" => report.data
       }))
diff --git a/script/run_cross_ruby.rb b/script/run_cross_ruby.rb
new file mode 100644
index 0000000..566b22f
--- /dev/null
+++ b/script/run_cross_ruby.rb
@@ -0,0 +1,157 @@
+# Runs every build on this one machine, one after the other, so their i/s can be compared (the "Across Rubies" view of the results site):
+#
+#   ruby script/run_cross_ruby.rb [--shard 0 --shards 6] [options]
+#
+# The reference build (the latest stable MRI) runs first, again after every few builds, and last.
+# It is the same code every time, so its passes show how steady the machine was during the run.
+# Each pass writes its results to <out>/pass-NN/<label>/, and the run order goes to <out>/order-<shard>.json (one per shard, so merged artifacts keep them all).
+# CI runs it from .github/workflows/results-site.yml.
+require "fileutils"
+require "json"
+require "optparse"
+require "yaml"
+require_relative "build_results_site"
+
+module CrossRuby
+  # The builds come from the CI matrix, so a Ruby added there (a service in compose.yaml and a matrix entry) is measured here too.
+  # The newest released MRI among them becomes the reference, the same rule that picks the site's default Ruby.
+  MATRIX = File.expand_path("../.github/workflows/benchmarks.yml", __dir__)
+
+  module_function
+
+  # Every build of the rake job's matrix, as [compose service, variant, flags]: the plain Rubies, then the include entries (the JIT builds).
+  def builds(workflow = MATRIX)
+    matrix = YAML.safe_load(File.read(workflow), aliases: true).dig("jobs", "rake", "strategy", "matrix")
+    abort "No rake matrix in #{workflow}" unless matrix && matrix["ruby"]
+
+    plain = matrix["ruby"].map { |s| [s, nil, nil] }
+    variants = (matrix["include"] || []).map { |i| [i["ruby"], i["variant"], i["flags"]] }
+    (plain + variants).freeze
+  end
+
+  def label(build)
+    [build[0], build[1]].compact.join("+")
+  end
+
+  # Every shards-th file of the sorted list, so each shard gets a mix of sections.
+  def shard_files(files, shard, shards)
+    files.sort.each_with_index.select { |_, i| i % shards == shard }.map(&:first)
+  end
+
+  # The reference first, after every `every` builds, and last.
+  # The other builds are shuffled with the seed (so a run can be repeated) by Ruby: a Ruby's interpreter and JIT builds run back to back, so each image is fetched once and the JIT is compared with the interpreter minutes apart.
+  def passes(builds, reference, every, seed)
+    random = Random.new(seed)
+    groups = builds.reject { |b| b == reference }.group_by(&:first).values
+    others = groups.shuffle(random: random).flat_map { |g| g.shuffle(random: random) }
+    [reference] + others.each_slice(every).flat_map { |slice| slice + [reference] }
+  end
+
+  def capture(cmd)
+    IO.popen(cmd, &:read)
+  end
+
+  def run(argv)
+    opts = { shard: 0, shards: 1, every: 3, out: "results", seed: (ENV["GITHUB_RUN_ID"] || rand(1 << 31)).to_i }
+    OptionParser.new do |o|
+      o.on("--shard N", Integer, "Which shard to run, from 0 (default 0)") { |v| opts[:shard] = v }
+      o.on("--shards N", Integer, "How many shards the files are split into (default 1)") { |v| opts[:shards] = v }
+      o.on("--every N", Integer, "Run the reference again after every N builds (default 3)") { |v| opts[:every] = v }
+      o.on("--seed N", Integer, "Seed for the build order (default: the CI run id, or random)") { |v| opts[:seed] = v }
+      o.on("--out DIR", "Where results go (default results)") { |v| opts[:out] = v }
+      o.on("--files A,B", Array, "Only these benchmark files") { |v| opts[:files] = v }
+      o.on("--builds A,B", Array, "Only these builds, by label (ruby_3.4, ruby_3.4+yjit)") { |v| opts[:builds] = v }
+      o.on("--project NAME", "docker compose project name (-p)") { |v| opts[:project] = v }
+      o.on("--fresh-images", "Pull or build each image first and remove it after (CI: keeps the disk free)") { opts[:fresh] = true }
+      o.on("--dry-run", "Print the commands instead of running them") { opts[:dry] = true }
+    end.parse!(argv)
+    abort "--shard must be between 0 and #{opts[:shards] - 1}" unless (0...opts[:shards]).cover?(opts[:shard])
+    # Paths below (code/, --files, --out) are from the repo root.
+    # The benchmarks write their results from inside a container that only sees the repo (mounted at /app), so --out has to be inside it.
+    root = File.expand_path("..", __dir__)
+    out = File.expand_path(opts[:out], root)
+    abort "--out must be a folder inside #{root}: the benchmarks write their results from a container that only sees the repo" unless out.start_with?(root + File::SEPARATOR)
+    opts[:out] = out.delete_prefix(root + File::SEPARATOR)
+    Dir.chdir(root)
+
+    all = builds
+    builds = all
+    if opts[:builds]
+      unknown = opts[:builds] - all.map { |b| label(b) }
+      abort "Unknown builds: #{unknown.join(", ")}" unless unknown.empty?
+      builds = all.select { |b| opts[:builds].include?(label(b)) }
+    end
+    # The same rule as the site's default Ruby: the newest released MRI.
+    ref_label = ResultsSite.default_label(builds.map { |b| label(b) })
+    reference = builds.find { |b| label(b) == ref_label }
+    abort "No MRI build to use as the reference" unless reference && reference[0].start_with?("ruby_") && !reference[1]
+
+    files = shard_files(opts[:files] || Dir["code/*/*.rb"], opts[:shard], opts[:shards])
+    abort "No benchmark files in shard #{opts[:shard]}" if files.empty?
+    order = passes(builds, reference, opts[:every], opts[:seed])
+
+    puts "Shard #{opts[:shard]} of #{opts[:shards]}: #{files.size} files, #{order.size} passes, reference #{ref_label}, seed #{opts[:seed]}"
+    puts "Order: #{order.map { |b| label(b) }.join(" ")}"
+    FileUtils.mkdir_p(opts[:out])
+    compose = ["docker", "compose"] + (opts[:project] ? ["-p", opts[:project]] : [])
+    # Services built from docker/Dockerfile (the head builds, TruffleRuby 22); the rest are pulled.
+    built = JSON.parse(capture(compose + ["config", "--format", "json"]))["services"].select { |_, svc| svc["build"] }.keys
+    # With --fresh-images: an image is fetched before its service's first pass
+    # and removed after its last one; the reference's image stays to the end.
+    last_pass = order.each_with_index.to_h { |b, i| [b[0], i] }
+    ready = {}
+    log = { seed: opts[:seed], shard: opts[:shard], shards: opts[:shards], every: opts[:every], reference: ref_label, files: files, passes: [] }
+    failed = []
+
+    order.each_with_index do |build, pass|
+      service, variant, flags = build
+      name = label(build)
+      ref = build.equal?(reference)
+      puts "", "== Pass #{pass + 1} of #{order.size}: #{name}#{" (reference)" if ref}"
+      if opts[:fresh] && !ready.key?(service)
+        prepare = built.include?(service) ? "build" : "pull"
+        ready[service] = sh(compose + [prepare, service], opts)
+      end
+      if ready[service] == false
+        failed << "#{name} (image #{built.include?(service) ? "build" : "pull"} failed)"
+        next
+      end
+
+      env = {
+        "RESULTS_DIR" => File.join(opts[:out], format("pass-%02d", pass + 1)),
+        "RESULTS_LABEL" => name,
+        "RESULTS_PASS" => (pass + 1).to_s,
+        "RESULTS_REFERENCE" => ref ? "1" : "",
+        "RESULTS_SHARD" => opts[:shard].to_s,
+        "RESULTS_SHARDS" => opts[:shards].to_s,
+        "RUBY_VARIANT" => variant.to_s,
+        "RUBY_VARIANT_FLAGS" => flags.to_s
+      }
+      started = Time.now.utc
+      ok = sh(compose + ["run", "--rm", "-T", service] + files, opts, env)
+      failed << name unless ok
+      log[:passes] << { pass: pass + 1, label: name, reference: ref, started_at: started.strftime("%FT%TZ"), finished_at: Time.now.utc.strftime("%FT%TZ"), ok: ok }
+
+      if opts[:fresh] && last_pass[service] == pass && service != reference[0]
+        images = capture(compose + ["config", "--images", service]).split
+        sh(["docker", "image", "rm", "-f"] + images, opts) unless images.empty?
+      end
+    end
+
+    File.write(File.join(opts[:out], "order-#{opts[:shard]}.json"), JSON.pretty_generate(log)) unless opts[:dry]
+    return if failed.empty?
+
+    warn "", "Failed passes (their other results were kept):", *failed
+    exit 1
+  end
+
+  def sh(cmd, opts, env = {})
+    if opts[:dry]
+      puts((env.reject { |_, v| v.empty? }.map { |k, v| "#{k}=#{v}" } + cmd).join(" "))
+      return true
+    end
+    system(env, *cmd)
+  end
+end
+
+CrossRuby.run(ARGV) if $PROGRAM_NAME == __FILE__

From 597d07171701e78e6e62abf01378675856c907a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20V=C3=A1squez?= <juan@ombulabs.com>
Date: Tue, 6 Oct 2026 13:43:36 -0600
Subject: [PATCH 2/6] Step 2: Run the builds across Rubies every week

A new workflow, Results site (results-site.yml), runs
script/run_cross_ruby.rb in 6 shards, each on its own runner: every 6th
benchmark file, all 26 builds. A shard takes about 3 hours, under the 6
hour job limit, so it runs once a week (Sunday 03:00 UTC) and by hand.
Each shard uploads its results.
---
 .github/workflows/results-site.yml | 43 ++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 .github/workflows/results-site.yml

diff --git a/.github/workflows/results-site.yml b/.github/workflows/results-site.yml
new file mode 100644
index 0000000..d44fa49
--- /dev/null
+++ b/.github/workflows/results-site.yml
@@ -0,0 +1,43 @@
+name: Results site
+
+# Builds and publishes the results site (https://fastruby.github.io/fast-ruby/).
+# Every Ruby runs each benchmark on the same machine, so the site can compare i/s across Rubies; benchmarks.yml runs each Ruby on its own machine and only checks that the benchmarks run.
+# Weekly, because a full run takes about 3 hours per shard; run it by hand to publish sooner.
+on:
+  schedule:
+    # Sunday 03:00 UTC, away from the working day's PR runs.
+    - cron: '0 3 * * 0'
+  workflow_dispatch:
+
+jobs:
+  # 6 machines, each running every 6th benchmark file on all 26 builds, with the newest released Ruby run again between them (script/run_cross_ruby.rb).
+  shard:
+    name: shard ${{ matrix.shard }}
+    runs-on: ubuntu-latest
+    # 35 passes of about 13 files each; the job limit is 6 hours.
+    timeout-minutes: 330
+
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [0, 1, 2, 3, 4, 5]
+
+    # Read by docker/collect_results.rb.
+    env:
+      RESULTS_COMMIT: ${{ github.sha }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run every build on this machine
+        run: ruby script/run_cross_ruby.rb --shard ${{ matrix.shard }} --shards 6 --fresh-images --out results
+      # Also when a pass failed: the shard's other results are kept, to see what went wrong (the site is not built from an incomplete run).
+      - name: Upload results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: results-shard-${{ matrix.shard }}
+          path: results/
+          retention-days: 90
+          # A re-run of a failed shard replaces its earlier attempt.
+          overwrite: true
+

From 64b0ccba8ac95c301bb34996e5c2cee9a1590494 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20V=C3=A1squez?= <juan@ombulabs.com>
Date: Tue, 6 Oct 2026 13:43:36 -0600
Subject: [PATCH 3/6] Step 3: Build both views from the run across Rubies

The site builder now reads a run of script/run_cross_ruby.rb and builds
both views from it, into across-rubies.json and does-it-hold.json
(named after the views). across-rubies.json has, per benchmark, every build's i/s
and error as measured and relative to the reference's median, and how much
the reference varied over its passes (standard deviation over mean). A
benchmark over 5% is marked noisy; when the typical benchmark is, the page
warns that small differences between Rubies may be the machine.

"Does it hold?" comes from the same run: every build's result, and the
reference's middle pass. Each verdict still compares reports inside one
run, and now every build of a benchmark shares one machine.

On the first run on GitHub runners the reference varied 2.3% on the typical
benchmark, with no drift over the run (last third within 0.1% of the
first). Correcting each build by the reference's speed at the time made
the lines jumpier (7.6% against 7.0% between MRI versions), as it did in
two local pilots, so the numbers are shown as measured.
---
 script/build_results_site.rb | 209 ++++++++++++++++++++++++++++-------
 script/results_site.html     |   5 +-
 2 files changed, 169 insertions(+), 45 deletions(-)

diff --git a/script/build_results_site.rb b/script/build_results_site.rb
index 268993a..e98e55a 100644
--- a/script/build_results_site.rb
+++ b/script/build_results_site.rb
@@ -1,13 +1,12 @@
-# Builds the results site from the JSON written by docker/collect_results.rb:
+# Builds the results site from a run of script/run_cross_ruby.rb, where every build of a benchmark ran on one machine:
 #
-#   ruby script/build_results_site.rb [results_dir] [output_dir]
+#   ruby script/build_results_site.rb <results_dir> [output_dir]
 #
-# results_dir defaults to results/ and output_dir to _site/. Result files are
-# found at any depth, so both a local results/<label>/ folder and CI's merged
-# artifacts work. The site answers one question per benchmark: does the
-# report the file claims is fastest win on this Ruby and build? Every verdict
-# compares reports inside one run, never one Ruby or build against another:
-# each build ran as its own CI job, often on a different CPU model.
+# output_dir defaults to _site/. Result files are found at any depth, so both a local folder and CI's merged artifacts work.
+# The site has two views, both from that run:
+#
+# - "Across Rubies": i/s on every build, with the reference build's passes showing how steady that machine was.
+# - "Does it hold?": does the report the file claims is fastest win on this Ruby and build?
 require "fileutils"
 require "json"
 
@@ -20,6 +19,11 @@ module ResultsSite
   # most likely removed the work (TruffleRuby reports hundreds of billions).
   SUSPECT_IPS = 1e9
 
+  # How much the reference build's i/s may vary over its passes (standard deviation / mean) before a benchmark is marked noisy.
+  # When the typical benchmark of a run is over it, the page warns that small differences between Rubies may be the machine.
+  # On GitHub runners (first run, 2026-10-06) the typical benchmark varied 2.3% and 7 of 78 went over 5%.
+  GATE = 0.05
+
   # Sections come from the folder under code/, in this order.
   # A folder not listed here is shown after these, with its name capitalized.
   SECTIONS = {
@@ -39,18 +43,31 @@ module ResultsSite
   module_function
 
   def build(results_dir, output_dir)
-    # Only result files: anything else under results_dir
-    # (a site built there earlier, another artifact) has no "entries".
-    reports = Dir[File.join(results_dir, "**", "*.json")].sort.map { |path| JSON.parse(File.read(path)) }
-    reports.select! { |r| r.is_a?(Hash) && r["entries"].is_a?(Array) && r["label"] }
-    abort "No results found in #{results_dir}" if reports.empty?
+    reports = load_reports(results_dir)
+    abort "No results from script/run_cross_ruby.rb found in #{results_dir}" if reports.empty?
+    across_rubies = across_rubies_data(reports)
+    does_it_hold = does_it_hold_data(does_it_hold_reports(reports))
 
-    data = site_data(reports)
     FileUtils.rm_rf(output_dir)
     FileUtils.mkdir_p(output_dir)
-    File.write(File.join(output_dir, "index.html"), render(data))
-    File.write(File.join(output_dir, "results.json"), JSON.generate(data))
-    puts "Built #{data[:benchmarks].size} benchmarks on #{data[:meta][:labels].size} builds into #{output_dir}"
+    File.write(File.join(output_dir, "index.html"), render(does_it_hold, across_rubies))
+    File.write(File.join(output_dir, "does-it-hold.json"), JSON.generate(does_it_hold))
+    File.write(File.join(output_dir, "across-rubies.json"), JSON.generate(across_rubies))
+    puts "#{across_rubies[:benchmarks].size} benchmarks on #{across_rubies[:meta][:labels].size} builds"
+    puts "Built into #{output_dir}"
+  end
+
+  # Only results from script/run_cross_ruby.rb, which have a pass number: anything else under the folder (a site built there earlier, another artifact, its order files) is left out.
+  def load_reports(dir)
+    reports = Dir[File.join(dir, "**", "*.json")].sort.map { |path| JSON.parse(File.read(path)) }
+    reports.select { |r| r.is_a?(Hash) && r["entries"].is_a?(Array) && r["label"] && r["pass"] }
+  end
+
+  # "Does it hold?" from a cross-Ruby run: every build's result, and for the reference build, which ran many times, its pass in the middle of the run.
+  def does_it_hold_reports(reports)
+    refs, others = reports.partition { |r| r["reference"] }
+    middle = refs.group_by { |r| [r["benchmark"], r["part"]] }.values.map { |rs| rs.sort_by { |r| r["pass"] }[rs.size / 2] }
+    others + middle
   end
 
   # The claim is the first report: the lint guarantees the claimed one (the
@@ -82,41 +99,146 @@ def overlaps?(a, b)
     a["ips"] + a["error"] > b["ips"] - b["error"] && a["ips"] - a["error"] < b["ips"] + b["error"]
   end
 
-  def site_data(reports)
+  # Every build of a benchmark ran on one machine, recorded per benchmark.
+  def does_it_hold_data(reports)
     labels = reports.map { |r| r["label"] }.uniq.sort_by { |l| label_sort_key(l) }
     grouped = reports.group_by { |r| [r["benchmark"], r["part"]] }
     multi_part = grouped.keys.group_by(&:first).select { |_, parts| parts.size > 1 }.keys
 
     benchmarks = grouped.map do |(file, part), runs|
-      # The run with the most reports has them all; older Rubies can skip a
-      # report guarded by RUBY_VERSION.
-      names = runs.max_by { |r| r["entries"].size }["entries"].map { |e| e["name"] }
-      title = title_for(names)
-      title += " (part #{part})" if multi_part.include?(file)
-      {
-        file: file,
-        part: part,
-        title: title,
-        section: section_for(file),
-        names: names,
-        runs: runs.to_h { |r| [r["label"], run_data(r, names)] }
-      }
+      names = names_of(runs)
+      b = describe(file, part, names, multi_part).merge(runs: runs.to_h { |r| [r["label"], run_data(r, names)] })
+      b[:cpu] = runs.first.dig("environment", "cpu")
+      b
     end
 
+    { meta: meta(reports, labels), benchmarks: in_order(benchmarks) }
+  end
+
+  # The run with the most reports has them all; older Rubies can skip a
+  # report guarded by RUBY_VERSION.
+  def names_of(runs)
+    runs.max_by { |r| r["entries"].size }["entries"].map { |e| e["name"] }
+  end
+
+  def describe(file, part, names, multi_part)
+    title = title_for(names)
+    title += " (part #{part})" if multi_part.include?(file)
+    { file: file, part: part, title: title, section: section_for(file), names: names }
+  end
+
+  def in_order(benchmarks)
     order = SECTIONS.values
     benchmarks.sort_by! { |b| [order.index(b[:section]) || order.size, b[:section], b[:file], b[:part]] }
     # Two files with the same report labels get their file name added.
     benchmarks.group_by { |b| b[:title] }.each_value do |same|
       same.each { |b| b[:title] += " (#{File.basename(b[:file])})" } if same.size > 1
     end
+    benchmarks
+  end
+
+  # Across Rubies. Every build of a benchmark ran on one machine (one shard), and the reference build ran first, between the others and last.
+  # The page shows i/s as measured.
+  # The reference's passes show how steady the machine was: it is the same code every time, so how much its i/s varies is the machine.
+  # Correcting the other builds by the reference's speed at the time was tried and dropped: on GitHub runners and in local pilots it made the lines jumpier, since the variation was noise, not drift.
+  def across_rubies_data(reports)
+    labels = reports.map { |r| r["label"] }.uniq.sort_by { |l| label_sort_key(l) }
+    reference = reports.find { |r| r["reference"] }&.fetch("label")
+    grouped = reports.group_by { |r| [r["benchmark"], r["part"]] }
+    multi_part = grouped.keys.group_by(&:first).select { |_, parts| parts.size > 1 }.keys
+
+    benchmarks = grouped.map do |(file, part), runs|
+      names = names_of(runs)
+      passes = runs.select { |r| r["reference"] }
+      # The reference's usable i/s per report: suspect (or zero) passes left out.
+      ref_ips = names.map { |n| passes.filter_map { |r| e = entry(r, n); e["ips"] if e && e["ips"].positive? && e["ips"] <= SUSPECT_IPS } }
+      builds = runs.reject { |r| r["reference"] }.to_h { |r| [r["label"], cross_run(r, names, ref_ips)] }
+      builds[reference] = reference_run(passes, names, ref_ips) if reference && passes.any?
+      moved = variation(ref_ips)
+      describe(file, part, names, multi_part).merge(
+        shard: runs.first["shard"],
+        cpu: runs.first.dig("environment", "cpu"),
+        reference_passes: passes.size,
+        variation: moved&.round(4),
+        noisy: !moved.nil? && moved > GATE,
+        runs: builds
+      )
+    end
+
+    { meta: cross_meta(reports, labels, reference, benchmarks), benchmarks: in_order(benchmarks) }
+  end
 
-    { meta: meta(reports, labels), benchmarks: benchmarks }
+  def entry(report, name)
+    report["entries"].find { |e| e["name"] == name }
+  end
+
+  # Per report: [i/s, error, relative to the reference's median]. Relative is nil for a suspect or zero result, or a report the reference does not have.
+  def cross_run(report, names, ref_ips)
+    entries = names.each_with_index.map do |name, i|
+      e = entry(report, name) or next nil
+      rel = ref_ips[i].empty? || !e["ips"].positive? || e["ips"] > SUSPECT_IPS ? nil : (e["ips"] / median(ref_ips[i])).round(4)
+      [e["ips"].round(3), e["error"].to_f.round(1), rel]
+    end
+    { entries: entries, pass: report["pass"] }
+  end
+
+  # The reference itself: its median pass, 1.0 relative to itself.
+  def reference_run(passes, names, ref_ips)
+    entries = names.each_with_index.map do |name, i|
+      es = passes.filter_map { |r| entry(r, name) }
+      next nil if es.empty?
+
+      usable = es.select { |e| e["ips"].positive? && e["ips"] <= SUSPECT_IPS }
+      pick = usable.empty? ? es : usable
+      [median(pick.map { |e| e["ips"] }).round(3), median(pick.map { |e| e["error"].to_f }).round(1), ref_ips[i].empty? ? nil : 1.0]
+    end
+    { entries: entries, passes: passes.map { |r| r["pass"] }.sort }
+  end
+
+  # How much the reference varied over its passes: standard deviation / mean per report, the median over the reports; nil with fewer than two passes.
+  def variation(ref_ips)
+    cvs = ref_ips.select { |v| v.size > 1 }.map do |v|
+      mean = v.sum / v.size
+      Math.sqrt(v.sum { |x| (x - mean)**2 } / (v.size - 1)) / mean
+    end
+    cvs.empty? ? nil : median(cvs)
+  end
+
+  def median(values)
+    s = values.sort
+    s.size.odd? ? s[s.size / 2] : (s[s.size / 2 - 1] + s[s.size / 2]) / 2.0
+  end
+
+  def cross_meta(reports, labels, reference, benchmarks)
+    first = reports.first
+    moved = benchmarks.filter_map { |b| b[:variation] }
+    typical = moved.empty? ? nil : median(moved)
+    shards = reports.group_by { |r| r["shard"] }.sort_by { |k, _| k.to_i }.map do |shard, rs|
+      times = rs.map { |r| r["measured_at"] }.sort
+      { shard: shard, cpu: rs.first.dig("environment", "cpu"), nproc: rs.first.dig("environment", "nproc"), from: times.first, to: times.last }
+    end
+    {
+      commit: first["commit"],
+      run_id: first["run_id"],
+      shards_total: first["shards"],
+      built_at: Time.now.utc.strftime("%Y-%m-%d %H:%M UTC"),
+      repo: REPO_URL,
+      labels: labels,
+      reference: reference,
+      gate: GATE,
+      variation: typical&.round(4),
+      passed: !typical.nil? && typical <= GATE,
+      suspect: SUSPECT_IPS,
+      shards: shards,
+      descriptions: reports.group_by { |r| r["label"] }.transform_values { |rs| rs.first["ruby_description"] }
+    }
   end
 
   # Per build: the verdict, and ips/error per report in the order of `names`
   # (nil where that report did not run).
+  # A 0 i/s result (a broken run) counts as not run: a ratio against it would be infinite, which JSON cannot hold.
   def run_data(report, names)
-    entries = report["entries"]
+    entries = report["entries"].select { |e| e["ips"].positive? }
     v = verdict(entries, names.first)
     by_name = entries.to_h { |e| [e["name"], e] }
     v[:ratio] = v[:ratio].round(4) if v[:ratio]
@@ -130,15 +252,11 @@ def meta(reports, labels)
     {
       commit: first["commit"],
       run_id: first["run_id"],
-      pr: first["pr"],
-      # Set by CI when a benchmark job failed: its results are missing, which looks like a skip.
-      incomplete: ENV["RESULTS_INCOMPLETE"] == "1",
       built_at: Time.now.utc.strftime("%Y-%m-%d %H:%M UTC"),
       repo: REPO_URL,
       labels: labels,
       default: default_label(labels),
-      descriptions: by_label.transform_values { |r| r["ruby_description"] },
-      cpus: by_label.transform_values { |r| r.dig("environment", "cpu") }
+      descriptions: by_label.transform_values { |r| r["ruby_description"] }
     }
   end
 
@@ -168,11 +286,16 @@ def section_for(file)
     SECTIONS.fetch(folder) { folder.split("-").map(&:capitalize).join(" ") }
   end
 
-  # The data goes inline so the page also works opened from disk. "</" is
-  # escaped so a report name can never close the script tag.
-  def render(data)
-    json = JSON.generate(data).gsub("</", "<\\/").gsub("\u2028", "\\u2028").gsub("\u2029", "\\u2029")
-    File.read(TEMPLATE).sub("/*RESULTS_DATA*/") { "window.RESULTS = #{json};" }
+  # The data goes inline so the page also works opened from disk.
+  # "</" is escaped so a report name can never close the script tag.
+  def render(does_it_hold, across_rubies = nil)
+    File.read(TEMPLATE)
+        .sub("/*DOES_IT_HOLD_DATA*/") { "window.DOES_IT_HOLD = #{inline(does_it_hold)};" }
+        .sub("/*ACROSS_RUBIES_DATA*/") { "window.ACROSS_RUBIES = #{inline(across_rubies)};" }
+  end
+
+  def inline(data)
+    JSON.generate(data).gsub("</", "<\\/").gsub("\u2028", "\\u2028").gsub("\u2029", "\\u2029")
   end
 end
 
diff --git a/script/results_site.html b/script/results_site.html
index c2a356b..db38c55 100644
--- a/script/results_site.html
+++ b/script/results_site.html
@@ -276,11 +276,12 @@ <h2 class="bh">FastRuby<span>.io</span> keeps fast-ruby running</h2>
 </footer>
 
 <script>
-/*RESULTS_DATA*/
+/*DOES_IT_HOLD_DATA*/
+/*ACROSS_RUBIES_DATA*/
 </script>
 <script>
 (function () {
-  const D = window.RESULTS, M = D.meta, B = D.benchmarks;
+  const D = window.DOES_IT_HOLD, M = D.meta, B = D.benchmarks;
   const $ = (id) => document.getElementById(id);
   const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
   const md = (s) => esc(s).replace(/`([^`]+)`/g, "<code>$1</code>");

From 5b22884e1742a13cba1298c2446c5014ec89992a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20V=C3=A1squez?= <juan@ombulabs.com>
Date: Tue, 6 Oct 2026 13:43:36 -0600
Subject: [PATCH 4/6] Step 4: Show Across Rubies first on the results site

The page gets a second view, Across Rubies, and opens on it. Per
benchmark: a chart with the Rubies on the x axis (MRI as a line, JRuby
and TruffleRuby as points), one line per report with the claimed one in
green, a JIT switch with the interpreter dashed under it, i/s or relative
to the reference, a table of every build, and how steady the machine was.

Two Rubies count as same-ish when their error bars overlap or their gap is
within how much the reference varied on that machine: runs minutes apart
vary more than benchmark-ips' error bars say. "Does it hold?" now says
every build of a benchmark ran on one machine, so its columns compare.

Both views keep their choices in the URL (view, and build, which they
share) and leave each other's alone, also on load.
---
 script/results_site.html | 413 +++++++++++++++++++++++++++++++++++----
 1 file changed, 380 insertions(+), 33 deletions(-)

diff --git a/script/results_site.html b/script/results_site.html
index db38c55..be96fcd 100644
--- a/script/results_site.html
+++ b/script/results_site.html
@@ -4,7 +4,7 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
 <title>fast-ruby results</title>
-<meta name="description" content="Does the fast-ruby advice hold on your Ruby? Every benchmark, on every Ruby from 2.1 to head, with and without the JIT.">
+<meta name="description" content="How fast is each fast-ruby idiom on each Ruby, and does the advice hold on yours? Every benchmark, on every Ruby from 2.1 to head, with and without the JIT.">
 <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Cpath d='M2 11 8 4h16l6 7-14 17z' fill='%23ff0000'/%3E%3C/svg%3E">
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
@@ -29,6 +29,15 @@
   --yellow: #fdca31;
   --yellow-ink: #7a5c00;
   --skip: #d0d0d0;
+  --grid: #eeeeee;
+  /* Chart series, claimed report first: up to 6 reports, checked for color blindness on neighbouring lines.
+     --s5 and --s6 are under 3:1 contrast, so every chart also has a legend and a table. */
+  --s1: #00952f;
+  --s2: #2a78d6;
+  --s3: #eb6834;
+  --s4: #4a3aa7;
+  --s5: #eda100;
+  --s6: #e87ba4;
   --font: "Oxygen", system-ui, -apple-system, "Segoe UI", sans-serif;
   --mono: "Source Code Pro", ui-monospace, SFMono-Regular, Menlo, monospace;
 }
@@ -58,8 +67,8 @@
 .intro p { margin: 0 auto; color: var(--muted); max-width: 58ch; font-size: 15px; }
 .intro p.run { margin-top: 10px; font-size: 13px; color: var(--faint); }
 .intro p.run a { color: var(--muted); }
-.intro p.incomplete { margin: 14px auto 0; max-width: 58ch; padding: 10px 14px; border: 2px solid var(--red); color: var(--ink); font-size: 14px; font-weight: 700; }
-.intro p.incomplete[hidden] { display: none; }
+.intro p.note { margin: 14px auto 0; max-width: 58ch; padding: 10px 14px; border: 2px solid var(--red); color: var(--ink); font-size: 14px; font-weight: 700; }
+.intro p.note[hidden] { display: none; }
 
 .picker { position: sticky; top: env(safe-area-inset-top, 0px); z-index: 5; background: var(--bg); padding-block: 16px; border-bottom: 3px solid var(--ink); display: grid; gap: 10px; }
 .current { font-size: clamp(22px, 4vw, 30px); font-weight: 700; color: var(--ink); line-height: 1.2; display: flex; flex-wrap: wrap; align-items: center; gap: 6px 12px; }
@@ -182,6 +191,52 @@
 footer { border-top: 1px solid var(--line); font-size: 13px; color: var(--muted); }
 footer .col { padding-block: 18px 30px; display: flex; flex-wrap: wrap; gap: 6px 20px; }
 
+/* The two views, Across Rubies first. */
+.views { display: flex; justify-content: center; padding-top: 18px; }
+.views div { display: inline-flex; border: 2px solid var(--ink); }
+.views button { font: 700 13px var(--font); letter-spacing: .04em; text-transform: uppercase; background: var(--bg); color: var(--ink); border: 0; padding: 9px 16px; cursor: pointer; }
+.views button[aria-pressed="true"] { background: var(--ink); color: #fff; }
+.views button:hover:not([aria-pressed="true"]) { background: var(--soft); }
+
+/* Across Rubies: one card per benchmark, a chart with the Rubies on the x axis. */
+.rcard { border-bottom: 1px solid var(--line); padding-block: 18px; display: grid; grid-template-columns: minmax(0, 1fr); gap: 8px; }
+.rcard h3 { margin: 0; font-size: 15.5px; line-height: 1.35; color: var(--ink); text-wrap: balance; }
+.rcard h3 code { font-weight: 400; }
+.rcard .say { margin: 0; font-size: 14px; color: var(--text); max-width: 75ch; }
+.rcard .say b { color: var(--ink); }
+.rlegend { display: flex; flex-wrap: wrap; gap: 4px 16px; font-size: 13px; color: var(--text); }
+.rlegend span { display: inline-flex; align-items: center; gap: 6px; }
+.rlegend i { width: 14px; height: 3px; border-radius: 2px; display: inline-block; }
+.rlegend .ghost i { height: 0; border-top: 2px dashed var(--faint); background: none; }
+.chart { position: relative; width: 100%; min-width: 0; }
+.chart svg { display: block; width: 100%; height: auto; overflow: visible; }
+.chart text { font-family: var(--mono); font-size: 11px; fill: var(--muted); }
+.chart .tick line { stroke: var(--grid); }
+.chart .base { stroke: var(--line); }
+.chart .cross { stroke: var(--faint); stroke-width: 1; opacity: 0; }
+.chart .cross.on { opacity: 1; }
+.chart .hit { fill: transparent; cursor: crosshair; }
+.tipbox { position: absolute; pointer-events: none; background: var(--ink); color: #fff; font: 13px/1.45 var(--font); padding: 8px 10px; width: max-content; max-width: min(280px, 80%); z-index: 4; }
+.tipbox b { display: block; font-family: var(--mono); font-size: 12.5px; margin-bottom: 3px; }
+.tipbox .r { display: flex; align-items: center; gap: 6px; font-family: var(--mono); font-size: 12px; }
+.tipbox .r i { width: 8px; height: 8px; border-radius: 50%; flex: none; box-shadow: 0 0 0 1.5px #fff; }
+.tipbox .n { color: #cfcfcf; font-size: 12px; margin-top: 3px; }
+.rfoot { display: flex; flex-wrap: wrap; gap: 4px 16px; font-size: 13px; color: var(--muted); }
+.rfoot .noisy { color: var(--red); font-weight: 700; }
+.rcard details summary { cursor: pointer; font-size: 13.5px; font-weight: 700; color: var(--ink); width: max-content; }
+.rcard .tb { overflow-x: auto; border: 1px solid var(--line); margin-top: 8px; }
+.rcard table { border-collapse: collapse; width: 100%; font-size: 13px; font-variant-numeric: tabular-nums; }
+.rcard th { text-align: right; font-size: 11.5px; text-transform: uppercase; letter-spacing: .05em; color: var(--muted); padding: 7px 9px; background: var(--soft); border-bottom: 1px solid var(--line); white-space: nowrap; }
+.rcard td { text-align: right; padding: 5px 9px; border-bottom: 1px solid var(--grid); font-family: var(--mono); font-size: 12.5px; white-space: nowrap; }
+.rcard th:first-child, .rcard td:first-child { text-align: left; }
+.rcard td:first-child { font-family: var(--font); font-size: 13px; }
+.rcard td small { color: var(--faint); font-size: 11.5px; margin-left: 4px; }
+.rcard td .sm { color: var(--yellow-ink); }
+.rcard td.off { color: var(--faint); }
+.rcard .links { font-size: 13px; }
+.rhow { padding-block: 22px 0; display: grid; gap: 8px; font-size: 14px; color: var(--muted); }
+.rhow p { margin: 0; max-width: 75ch; }
+
 @media (max-width: 820px) { .bwrap { grid-template-columns: minmax(0, 1fr); } }
 @media (max-width: 640px) {
   /* On a phone the pinned picker would cover most of the screen. */
@@ -211,11 +266,38 @@
 </header>
 
 <main class="col" id="top">
+  <nav class="views" aria-label="Views"><div id="views">
+    <button type="button" data-view="across-rubies">Across Rubies</button>
+    <button type="button" data-view="does-it-hold">Does it hold?</button>
+  </div></nav>
+
+  <div id="view-across-rubies" hidden>
+  <div class="intro">
+    <h1>How fast is each idiom on each Ruby?</h1>
+    <p>Every Ruby ran each benchmark on the same machine, one after the other, so here you can compare i/s across Rubies. A reference Ruby ran again and again between them, to show how steady the machine was during the run.</p>
+    <p class="run" id="rrun"></p>
+    <p class="note" id="rnote" hidden></p>
+  </div>
+
+  <div class="picker" id="rpicker">
+    <div class="prow"><span class="lbl">Build</span><div class="chips" id="rmodes"></div><span class="jkey" id="rhint"></span></div>
+    <div class="prow"><span class="lbl">Show</span><div class="chips" id="rshow"></div></div>
+  </div>
+
+  <div id="rout"></div>
+
+  <div class="rhow" id="rhow">
+    <p><b>How this is measured.</b> Each shard of benchmark files ran on one GitHub runner: every build, in a random order, with benchmark-ips' default timing. The numbers are i/s as measured.</p>
+    <p><b>How steady the machine was.</b> The reference Ruby ran first, again after every few builds, and last. It is the same code every time, so how much its i/s varies is the machine, not Ruby. Under each chart is that variation (standard deviation over mean). Over 5% the benchmark is marked noisy, and when the typical benchmark of a run is over 5%, the page warns at the top. Two Rubies whose i/s differ by less than that variation are shown as same-ish.</p>
+    <p>Only Rubies of the same run are compared. Weeks are not compared with each other: each week can land on a different CPU. Results over a billion iterations per second (under 1 ns each) are marked suspect and kept off the chart: the JIT most likely removed the work.</p>
+  </div>
+  </div>
+
+  <div id="view-does-it-hold">
   <div class="intro">
     <h1>Which fast-ruby advice holds on your Ruby?</h1>
     <p>Every benchmark names the idiom it claims is fastest. We run each one on every Ruby, with and without the JIT, and check whether the claim still wins on that Ruby.</p>
     <p class="run" id="run"></p>
-    <p class="incomplete" id="incomplete" hidden>Some benchmark jobs in this run failed. Their results are missing, so a result shown as skipped may be a crash. Check the CI run for the failed jobs.</p>
   </div>
 
   <div class="picker" id="picker">
@@ -242,6 +324,7 @@ <h1>Which fast-ruby advice holds on your Ruby?</h1>
     <span class="line"><span class="na"></span></span>skipped
     <span>Each dot is one Ruby, from 2.1 to head, then JRuby and TruffleRuby, that has the build you picked. The dot with the dark ring is the Ruby you selected, <b id="legendme"></b>. Hover a dot to see which Ruby it is.</span>
   </div>
+  </div>
 </main>
 
 <section class="band" id="sponsor" aria-label="Sponsor">
@@ -280,14 +363,48 @@ <h2 class="bh">FastRuby<span>.io</span> keeps fast-ruby running</h2>
 /*ACROSS_RUBIES_DATA*/
 </script>
 <script>
+// Two views, chosen by ?view=across-rubies (the default) or ?view=does-it-hold.
+// Each view keeps its own choices in the URL and leaves the others' alone.
+(function () {
+  const VIEWS = ["across-rubies", "does-it-hold"], preferred = "across-rubies";
+  const current = () => { const v = new URLSearchParams(location.search).get("view"); return VIEWS.includes(v) ? v : preferred; };
+  // Sets (or with null, removes) these URL parameters; push makes a history entry.
+  function setParams(values, push) {
+    const p = new URLSearchParams(location.search);
+    Object.entries(values).forEach(([k, v]) => (v == null || v === "" ? p.delete(k) : p.set(k, v)));
+    const q = p.toString();
+    const url = location.pathname + (q ? "?" + q : "") + location.hash;
+    if (url === location.pathname + location.search + location.hash) return;
+    try { history[push ? "pushState" : "replaceState"](null, "", url); } catch (e) { /* file:// in some browsers */ }
+  }
+  function show() {
+    const v = current();
+    VIEWS.forEach((x) => { document.getElementById("view-" + x).hidden = x !== v; });
+    document.querySelectorAll("#views button").forEach((b) => b.setAttribute("aria-pressed", String(b.dataset.view === v)));
+    document.dispatchEvent(new CustomEvent("viewchange", { detail: v }));
+  }
+  document.getElementById("views").addEventListener("click", (e) => {
+    const b = e.target.closest("button");
+    if (!b || b.dataset.view === current()) return;
+    setParams({ view: b.dataset.view === preferred ? null : b.dataset.view }, true);
+    window.scrollTo(0, 0);
+    show();
+  });
+  window.addEventListener("popstate", show);
+  document.getElementById("rubycount").textContent = window.ACROSS_RUBIES.meta.labels.length;
+  window.SiteViews = { current, setParams, show };
+})();
+</script>
+<script>
 (function () {
-  const D = window.DOES_IT_HOLD, M = D.meta, B = D.benchmarks;
   const $ = (id) => document.getElementById(id);
+  const D = window.DOES_IT_HOLD, M = D.meta, B = D.benchmarks;
   const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
   const md = (s) => esc(s).replace(/`([^`]+)`/g, "<code>$1</code>");
   const x = (r) => r >= 1e6 ? (r / 1e6).toFixed(1) + "M×" : r >= 1e4 ? Math.round(r / 1e3) + "k×" : r >= 10 ? Math.round(r) + "×" : r < 1.1 ? r.toFixed(2) + "×" : r.toFixed(1) + "×";
   const fmtIps = (v) => v >= 1e9 ? (v / 1e9).toFixed(2) + "B" : v >= 1e6 ? (v / 1e6).toFixed(2) + "M" : v >= 1e3 ? (v / 1e3).toFixed(1) + "k" : v.toFixed(1);
-  const cpu = (l) => (M.cpus[l] || "unknown").replace(/^AMD /, "").replace(/ \d+-Core Processor$/, "").replace(/^Intel\(R\) Xeon\(R\) Platinum (\S+) CPU.*$/i, "Xeon $1");
+  const cpuName = (c) => (c || "unknown").replace(/^AMD /, "").replace(/ \d+-Core Processor$/, "").replace(/^Intel\(R\) Xeon\(R\) Platinum (\S+) CPU.*$/i, "Xeon $1");
+
 
   const bases = M.labels.filter((l) => !l.includes("+"));
   const MODES = [["", "Interpreter"], ["yjit", "YJIT"], ["zjit", "ZJIT"]];
@@ -323,9 +440,9 @@ <h2 class="bh">FastRuby<span>.io</span> keeps fast-ruby running</h2>
     sus: "Suspect: a report ran over a billion times per second, under 1 ns per iteration. The JIT most likely removed the work, so these results are not counted as holds, ties or losses.",
     jit: "JIT changes the result: with YJIT or ZJIT on this Ruby, the verdict is different from the interpreter.",
     ips: "i/s is iterations per second: how many times benchmark-ips ran that code in one second. Higher is faster.",
-    cols: "Each build (interpreter, YJIT, ZJIT) ran as a separate CI job on its own machine. Read each column of a report on its own: it ranks the idioms inside that build. Do not compare i/s across columns to decide whether YJIT or ZJIT is faster.",
-    cpu: "The CPU model of the machine each build's job ran on. It is the same for every benchmark of that build in this run.",
-    cpuMixed: "These builds did not share a CPU model in this run, so their i/s numbers are even less comparable.",
+
+    same: "Every build of this benchmark (interpreter, YJIT, ZJIT, every Ruby) ran on the same machine, one after the other, so the columns can be compared: YJIT against the interpreter is a fair comparison here.",
+    cpuSame: "The CPU model of the machine every build of this benchmark ran on.",
   };
   const tip = (k) => `<button type="button" class="tip" aria-label="${esc(TIPS[k])}" data-tip="${esc(TIPS[k])}">!</button>`;
   const icon = { ok: "✓", eq: "=", no: "✗", na: "–" };
@@ -349,36 +466,20 @@ <h2 class="bh">FastRuby<span>.io</span> keeps fast-ruby running</h2>
     filter = FILTERS.includes(p.get("filter")) ? p.get("filter") : "all";
   }
   function toURL(push) {
-    const p = new URLSearchParams();
-    if (me !== M.default) p.set("ruby", shortLabel(me));
-    if (mode) p.set("build", mode);
-    if (filter !== "all") p.set("filter", filter);
-    const q = p.toString();
-    const url = location.pathname + (q ? "?" + q : "") + location.hash;
-    if (url === location.pathname + location.search + location.hash) return;
-    try { history[push ? "pushState" : "replaceState"](null, "", url); } catch (e) { /* file:// in some browsers */ }
+    window.SiteViews.setParams({ ruby: me !== M.default ? shortLabel(me) : null, build: mode || null, filter: filter !== "all" ? filter : null }, push);
   }
 
   $("chips").innerHTML = bases.map((l) => `<button type="button" class="chip" data-l="${esc(l)}">${esc(shortLabel(l).replace("truffleruby_", "truffle ").replace("jruby_", "jruby "))}${jitsOf(l).length ? '<span class="j" title="also built with YJIT or ZJIT"></span>' : ""}</button>`).join("");
-  $("rubycount").textContent = M.labels.length;
-  // Where the results come from: the live site shows a main run, a PR preview its PR, a local build no run at all.
+  // Where the results come from: the weekly run on main, or a local run.
   const runLink = M.run_id ? `<a href="${M.repo}/actions/runs/${esc(M.run_id)}">CI run ${esc(M.run_id)}</a>` : "a local run";
-  const where = M.pr ? `<a href="${M.repo}/pull/${esc(M.pr)}">PR #${esc(M.pr)}</a>` : M.run_id ? "<code>main</code>" : "";
   const at = M.commit ? ` @ <a href="${M.repo}/commit/${esc(M.commit)}">${esc(String(M.commit).slice(0, 7))}</a>` : "";
-  $("run").innerHTML = `Results from ${runLink}${where ? " on " + where : ""}${at}, built ${esc(M.built_at)}.`;
-  if (M.incomplete) {
-    $("incomplete").hidden = false;
-    TIPS.na += " In this run some benchmark jobs failed, so a skipped result may also be a crash.";
-  }
+  $("run").innerHTML = `Results from ${runLink}${at}, built ${esc(M.built_at)}.`;
 
   function detail(b) {
     const cols = ["", ...jitsOf(me)].map((m) => lab(me, m));
     const vs = cols.map((l) => b.v[l]);
     if (vs.every((v) => v.s === "na")) {
-      const why = M.incomplete
-        ? `No result on ${esc(nice(me))}: this benchmark needs a newer Ruby, or its job failed in this run (check the CI run).`
-        : `This benchmark needs a newer Ruby than ${esc(nice(me))}.`;
-      return `<div class="detail"><p class="fine">${why}</p></div>`;
+      return `<div class="detail"><p class="fine">This benchmark needs a newer Ruby than ${esc(nice(me))}.</p></div>`;
     }
     const head = cols.map((l, i) => `<th>${esc(i ? l.split("+")[1].toUpperCase() : "Interpreter")}<span class="v ${vs[i].s}">${short(vs[i])}</span>${vs[i].sus ? '<span class="v sus">! suspect</span>' : ""}</th>`).join("");
     const rows = b.names.map((nm) => `<tr class="${nm === b.names[0] ? "claimed" : ""}"><td><code>${esc(nm)}</code>${nm === b.names[0] ? " (claimed)" : ""}</td>` +
@@ -389,14 +490,14 @@ <h2 class="bh">FastRuby<span>.io</span> keeps fast-ruby running</h2>
         const ips = `<small class="ips">${fmtIps(e.ips)} i/s ±${((e.err / e.ips) * 100).toFixed(1)}%</small>`;
         return e === v.top ? `<td class="fast">fastest${ips}</td>` : `<td>${x(v.top.ips / e.ips)} slower${ips}</td>`;
       }).join("") + "</tr>").join("");
-    const envRow = `<tr class="env"><td>Ran on</td>${cols.map((l) => `<td title="${esc(M.cpus[l] || "")}">${esc(cpu(l))}</td>`).join("")}</tr>`;
+    // Every build of a benchmark ran on one machine.
+    const envRow = `<tr class="env"><td>Ran on</td>${cols.map(() => `<td title="${esc(b.cpu || "")}">${esc(cpuName(b.cpu))}</td>`).join("")}</tr>`;
     // How to read this table, next to it instead of in the pinned picker.
-    const mixedCpu = new Set(cols.map((l) => cpu(l))).size > 1;
     const used = new Set(vs.map((v) => (v.sus ? "sus" : v.s)));
     const words = [["ok", "holds"], ["eq", "tie"], ["no", "does not hold"], ["na", "skipped"], ["sus", "suspect"]]
       .filter(([k]) => ["ok", "eq", "no"].includes(k) || used.has(k))
       .map(([k, w]) => `${w}${tip(k)}`).join(", ");
-    const howto = `<p class="fine">Reading the numbers: ${words} · i/s${tip("ips")} · one machine per build${tip("cols")} · Ran on${tip(mixedCpu ? "cpuMixed" : "cpu")}</p>`;
+    const howto = `<p class="fine">Reading the numbers: ${words} · i/s${tip("ips")} · one machine for every build${tip("same")} · Ran on${tip("cpuSame")}</p>`;
     const built = bases.filter((l) => has(l, mode));
     const fails = built.filter((l) => b.v[lab(l, mode)].s === "no");
     const ran = built.filter((l) => b.v[lab(l, mode)].s !== "na").length;
@@ -492,6 +593,8 @@ <h2 class="bh">FastRuby<span>.io</span> keeps fast-ruby running</h2>
     render();
   });
   window.addEventListener("popstate", () => { fromURL(); render(); });
+  // The other view may have changed the build, which both views share.
+  document.addEventListener("viewchange", (e) => { if (e.detail === "does-it-hold") { fromURL(); render(); } });
   // iPhone Safari does not focus a button on tap, so :focus alone never
   // shows the text there: a tap toggles it, a tap anywhere else closes it.
   document.addEventListener("click", (e) => {
@@ -500,10 +603,254 @@ <h2 class="bh">FastRuby<span>.io</span> keeps fast-ruby running</h2>
     if (t) t.classList.toggle("open");
   });
 
+  // No URL write here: on load, a build the selected Ruby lacks falls back to the interpreter on screen only, so a build chosen in Across Rubies survives a reload.
   fromURL();
   render();
-  toURL(false);
 })();
 </script>
+<script>
+// Across Rubies. Each entry is [i/s, error, relative to the reference's median].
+(function () {
+  const $ = (id) => document.getElementById(id);
+  const D = window.ACROSS_RUBIES;
+  const M = D.meta, B = D.benchmarks, REF = M.reference;
+  const COLORS = ["var(--s1)", "var(--s2)", "var(--s3)", "var(--s4)", "var(--s5)", "var(--s6)"];
+  // A seventh report (none today) would reuse a color, never fail to draw.
+  const color = (i) => COLORS[i % COLORS.length];
+  const MODES = [["", "Interpreter"], ["yjit", "YJIT"], ["zjit", "ZJIT"]];
+  // Without the reference (its image failed, say), there is nothing to be relative to.
+  const SHOWS = REF ? [["ips", "i/s"], ["rel", "Relative to " + nice(REF)]] : [["ips", "i/s"]];
+  let mode = "", showing = "ips";
+
+  function esc(s) { return String(s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c])); }
+  function md(s) { return esc(s).replace(/`([^`]+)`/g, "<code>$1</code>"); }
+  function nice(l) { const [b, m] = l.split("+"); return b.replace(/^ruby_/, "Ruby ").replace(/^jruby_/, "JRuby ").replace(/^truffleruby_/, "TruffleRuby ") + (m ? " + " + m.toUpperCase() : ""); }
+  function short(l) { const [b, m] = l.split("+"); return b.replace(/^ruby_/, "").replace(/^jruby_/, "jruby ").replace(/^truffleruby_/, "truffle ") + (m ? " +" + m : ""); }
+  function fmt(v) { return v >= 1e9 ? (v / 1e9).toFixed(1) + "B" : v >= 1e6 ? (v / 1e6).toFixed(v >= 1e7 ? 1 : 2) + "M" : v >= 1e3 ? (v / 1e3).toFixed(v >= 1e5 ? 0 : 1) + "k" : v.toFixed(1); }
+  function pct(a, b) { const p = (a / b - 1) * 100; return (p >= 0 ? "+" : "") + p.toFixed(1) + "%"; }
+  function cpu(c) { return (c || "unknown CPU").replace(/^AMD /, "").replace(/ \d+-Core Processor$/, "").replace(/^Intel\(R\) Xeon\(R\) Platinum (\S+) CPU.*$/i, "Xeon $1"); }
+  const base = (l) => l.split("+")[0], variant = (l) => l.split("+")[1] || "", mri = (l) => /^ruby_/.test(l);
+  const has = (m) => M.labels.some((l) => variant(l) === m);
+  const sus = (e) => !!e && e[0] > M.suspect;
+  // A result that can be drawn and compared: it ran and is not suspect.
+  const ok = (e) => !!e && !sus(e) && e[0] > 0;
+  // Relative needs the reference to have that report.
+  const val = (e) => ok(e) ? (showing === "rel" ? e[2] : e[0]) : null;
+  // Two reports of one build, measured seconds apart: same-ish when the error bars overlap, as benchmark-ips says.
+  const same = (a, b) => a[0] + a[1] > b[0] - b[1] && a[0] - a[1] < b[0] + b[1];
+  // Two Rubies, measured minutes apart: also same-ish when the gap is within how much the reference varied on that machine, which is larger than benchmark-ips' error bars.
+  const sameRuby = (a, b, floor) => same(a, b) || Math.abs(a[0] / b[0] - 1) <= (floor || 0);
+
+  // The x axis: MRI builds of the selected build as a line, then (interpreter only) the other engines as points.
+  function columns() {
+    const line = M.labels.filter((l) => mri(l) && variant(l) === mode);
+    const other = mode ? [] : M.labels.filter((l) => !mri(l));
+    return { line, other, all: line.concat(other) };
+  }
+
+  function fromURL() {
+    const p = new URLSearchParams(location.search);
+    mode = MODES.some(([m]) => m && m === p.get("build")) && has(p.get("build")) ? p.get("build") : "";
+    showing = p.get("show") === "rel" && REF ? "rel" : "ips";
+  }
+
+  if (!M.passed) {
+    const why = [];
+    why.push(!REF
+      ? "The reference Ruby did not run in this run, so there is no way to tell how steady the machine was. Small differences between Rubies may be the machine, not Ruby."
+      : M.variation == null
+      ? "The reference Ruby ran only once in this run, so there is no way to tell how steady the machine was."
+      : `The machine was not steady during this run: the reference Ruby's i/s varied by ${(M.variation * 100).toFixed(1)}% on a typical benchmark (the limit is ${(M.gate * 100).toFixed(0)}%). Small differences between Rubies may be the machine, not Ruby.`);
+    $("rnote").textContent = why.join(" ");
+    $("rnote").hidden = false;
+  }
+  const runLink = M.run_id ? `<a href="${M.repo}/actions/runs/${esc(M.run_id)}">run ${esc(M.run_id)}</a>` : "a local run";
+  const at = M.commit ? ` @ <a href="${M.repo}/commit/${esc(M.commit)}">${esc(String(M.commit).slice(0, 7))}</a>` : "";
+  const day = M.shards.length ? M.shards[0].from.slice(0, 10) : "";
+  $("rrun").innerHTML = `Results from ${runLink}${at}, ${esc(day)}: ${M.labels.length} builds on ${M.shards.length} machine${M.shards.length === 1 ? "" : "s"}, built ${esc(M.built_at)}.`;
+
+  function summary(b) {
+    const plain = M.labels.filter((l) => !variant(l));
+    let wins = 0, ties = 0, ran = 0;
+    const ratios = [];
+    plain.forEach((l) => {
+      const r = b.runs[l];
+      if (!r || !ok(r.entries[0])) return;
+      const c = r.entries[0];
+      const others = r.entries.slice(1).filter(ok);
+      if (!others.length) return;
+      ran++;
+      const top = others.reduce((a, o) => (o[0] > a[0] ? o : a));
+      if (same(c, top)) ties++;
+      else if (c[0] > top[0]) { wins++; ratios.push([c[0] / top[0], l]); }
+    });
+    let s = `<code>${esc(b.names[0])}</code> is fastest on <b>${wins} of ${ran}</b> builds without a JIT`;
+    if (ties) s += ` (${ties} tie${ties > 1 ? "s" : ""})`;
+    if (ratios.length) {
+      ratios.sort((a, c) => a[0] - c[0]);
+      const lo = ratios[0], hi = ratios[ratios.length - 1];
+      s += lo === hi ? `, by ${lo[0].toFixed(1)}×` : `, by ${lo[0].toFixed(1)}× (${esc(nice(lo[1]))}) to ${hi[0].toFixed(1)}× (${esc(nice(hi[1]))})`;
+    }
+    const line = plain.filter((l) => mri(l) && l !== "ruby_head" && b.runs[l] && ok(b.runs[l].entries[0]));
+    if (line.length > 1) {
+      const first = line[0], last = line[line.length - 1];
+      s += `. Its own speed from ${esc(nice(first))} to ${esc(nice(last))}: <b>${pct(b.runs[last].entries[0][0], b.runs[first].entries[0][0])}</b>`;
+    }
+    return s + ".";
+  }
+
+  function ticks(max) {
+    if (!(max > 0) || !isFinite(max)) max = 1;
+    const raw = max / 4, mag = Math.pow(10, Math.floor(Math.log10(raw)));
+    const step = [1, 2, 2.5, 5, 10].map((m) => m * mag).find((x) => x >= raw);
+    const t = [];
+    for (let v = 0; ; v += step) { t.push(v); if (v >= max) break; }
+    return t;
+  }
+
+  function path(pts, c, extra, w) {
+    let d = "", pen = false;
+    pts.forEach((p) => { if (!p) { pen = false; return; } d += (pen ? "L" : "M") + p[0].toFixed(1) + "," + p[1].toFixed(1); pen = true; });
+    return d ? `<path d="${d}" fill="none" stroke="${c}" stroke-width="${w}" stroke-linejoin="round" stroke-linecap="round"${extra}/>` : "";
+  }
+
+  function chart(b, host) {
+    const cols = columns();
+    const W = Math.max(300, host.clientWidth || 300), H = W < 520 ? 210 : 250;
+    const P = { l: 54, r: 10, t: 14, b: 40 };
+    const gap = cols.other.length ? 22 : 0, n = Math.max(1, cols.all.length);
+    const band = (W - P.l - P.r - gap) / n;
+    const x = (k) => P.l + band * (k + 0.5) + (k >= cols.line.length ? gap : 0);
+    const ghost = mode ? cols.line.map(base) : [];
+    const vals = [];
+    b.names.forEach((_, i) => cols.all.concat(ghost).forEach((l) => { const r = b.runs[l]; const v = r && val(r.entries[i]); if (v != null) vals.push(v + (showing === "rel" ? r.entries[i][1] / r.entries[i][0] * v : r.entries[i][1])); }));
+    const tk = ticks(Math.max(...vals, showing === "rel" ? 1 : 1e-9));
+    const top = tk[tk.length - 1];
+    const y = (v) => P.t + (H - P.t - P.b) * (1 - v / top);
+    const lab = (t) => t === 0 ? "0" : showing === "rel" ? t.toFixed(t < 1 ? 2 : 1) + "×" : fmt(t);
+
+    let s = `<svg viewBox="0 0 ${W} ${H}" role="img" aria-label="${esc(b.names.join(" vs "))} on every Ruby">`;
+    tk.forEach((t) => { s += `<g class="tick"><line x1="${P.l}" x2="${W - P.r}" y1="${y(t)}" y2="${y(t)}"/><text x="${P.l - 8}" y="${y(t) + 4}" text-anchor="end">${lab(t)}</text></g>`; });
+    s += `<line class="base" x1="${P.l}" x2="${W - P.r}" y1="${y(0)}" y2="${y(0)}"/>`;
+    if (showing === "rel") s += `<line x1="${P.l}" x2="${W - P.r}" y1="${y(1)}" y2="${y(1)}" stroke="var(--faint)" stroke-dasharray="2 3"/>`;
+    cols.all.forEach((l, k) => {
+      const parts = short(l).split(" ");
+      s += `<text x="${x(k)}" y="${H - P.b + 16}" text-anchor="middle">${esc(parts[0])}</text>`;
+      if (parts[1]) s += `<text x="${x(k)}" y="${H - P.b + 29}" text-anchor="middle">${esc(parts.slice(1).join(" "))}</text>`;
+    });
+    if (cols.other.length) { const gx = x(cols.line.length) - band / 2 - gap / 2; s += `<line x1="${gx}" x2="${gx}" y1="${P.t}" y2="${y(0)}" stroke="var(--line)"/>`; }
+    // Under a JIT build: the same Rubies without it, dashed.
+    if (ghost.length) b.names.forEach((_, i) => { s += path(ghost.map((l, k) => { const r = b.runs[l], v = r && val(r.entries[i]); return v == null ? null : [x(k), y(v)]; }), color(i), ' stroke-dasharray="4 4" opacity=".55"', 1.5); });
+    b.names.forEach((_, i) => {
+      const c = color(i);
+      s += path(cols.line.map((l, k) => { const r = b.runs[l], v = r && val(r.entries[i]); return v == null ? null : [x(k), y(v)]; }), c, "", 2);
+      cols.all.forEach((l, k) => {
+        const r = b.runs[l], e = r && r.entries[i];
+        if (!e) return;
+        if (sus(e)) { const tx = x(k), ty = P.t + 2 + i * 9; s += `<path d="M${tx - 4},${ty + 6} L${tx},${ty} L${tx + 4},${ty + 6}Z" fill="var(--bg)" stroke="${c}" stroke-width="1.5"/>`; return; }
+        const v = val(e);
+        if (v == null) return;
+        const err = showing === "rel" ? e[1] / e[0] * v : e[1];
+        s += `<line x1="${x(k)}" x2="${x(k)}" y1="${y(Math.max(0, v - err))}" y2="${y(v + err)}" stroke="${c}" stroke-width="1" opacity=".5"/>`;
+        s += `<circle cx="${x(k)}" cy="${y(v)}" r="4" fill="${c}" stroke="var(--bg)" stroke-width="2"/>`;
+      });
+    });
+    s += `<line class="cross" y1="${P.t}" y2="${y(0)}" x1="0" x2="0"/>`;
+    cols.all.forEach((l, k) => { s += `<rect class="hit" data-k="${k}" x="${x(k) - band / 2}" y="${P.t}" width="${band}" height="${y(0) - P.t}"/>`; });
+    host.innerHTML = s + "</svg><div class=\"tipbox\" hidden></div>";
+
+    const tip = host.querySelector(".tipbox"), cross = host.querySelector(".cross");
+    host.querySelectorAll(".hit").forEach((h) => {
+      const on = () => {
+        const k = +h.dataset.k, l = cols.all[k], r = b.runs[l];
+        cross.setAttribute("x1", x(k)); cross.setAttribute("x2", x(k)); cross.classList.add("on");
+        let t = `<b>${esc(nice(l))}${l === REF ? " (reference)" : ""}</b>`;
+        if (!r) t += '<div class="n">Did not run: this benchmark needs a newer Ruby, or the build failed.</div>';
+        else {
+          b.names.forEach((nm, i) => {
+            const e = r.entries[i];
+            t += `<div class="r"><i style="background:${color(i)}"></i>${esc(nm)}: ${!e ? "did not run" : fmt(e[0]) + " i/s" + (sus(e) ? " (suspect)" : "")}</div>`;
+          });
+          const c = r.entries[0], o = r.entries[1];
+          if (ok(c) && ok(o)) t += `<div class="n">${same(c, o) ? "Same-ish: the gap is within the error." : `${esc(b.names[0])} is ${(c[0] / o[0]).toFixed(2)}× ${esc(b.names[1])}.`}</div>`;
+          const prev = k > 0 && k < cols.line.length && b.runs[cols.line[k - 1]];
+          const pc = prev && prev.entries[0];
+          if (ok(pc) && ok(c)) t += `<div class="n">vs ${esc(nice(cols.line[k - 1]))}: ${sameRuby(c, pc, b.variation) ? "same-ish" : pct(c[0], pc[0])}</div>`;
+          const g = mode && b.runs[base(l)], gc = g && g.entries[0];
+          if (ok(gc) && ok(c)) t += `<div class="n">vs no JIT: ${sameRuby(c, gc, b.variation) ? "same-ish" : pct(c[0], gc[0])}</div>`;
+        }
+        tip.innerHTML = t; tip.hidden = false;
+        const scale = host.clientWidth / W;
+        let left = x(k) * scale + 12;
+        if (left + tip.offsetWidth > host.clientWidth) left = x(k) * scale - 12 - tip.offsetWidth;
+        tip.style.left = Math.max(0, left) + "px"; tip.style.top = "6px";
+      };
+      h.addEventListener("mouseenter", on);
+      h.addEventListener("click", on);
+      h.addEventListener("mouseleave", () => { tip.hidden = true; cross.classList.remove("on"); });
+    });
+  }
+
+  function table(b) {
+    const cols = columns();
+    let h = `<tr><th>Build</th>${b.names.map((nm, i) => `<th>${esc(nm)}${i ? "" : " (claimed)"}</th>`).join("")}<th>Gap</th></tr>`;
+    cols.all.forEach((l, k) => {
+      const r = b.runs[l], prev = k > 0 && k < cols.line.length ? b.runs[cols.line[k - 1]] : null;
+      h += `<tr><td>${esc(nice(l))}${l === REF ? " (reference)" : ""}</td>`;
+      b.names.forEach((_, i) => {
+        const e = r && r.entries[i];
+        if (!e) { h += '<td class="off">did not run</td>'; return; }
+        if (sus(e)) { h += `<td class="off">${fmt(e[0])} suspect</td>`; return; }
+        if (!ok(e)) { h += '<td class="off">0 i/s</td>'; return; }
+        const pe = prev && prev.entries[i];
+        const d = ok(pe) ? (sameRuby(e, pe, b.variation) ? ' <small class="sm">same-ish</small>' : ` <small>${pct(e[0], pe[0])}</small>`) : "";
+        h += `<td>${fmt(e[0])} <small>±${(e[1] / e[0] * 100).toFixed(1)}%</small>${d}</td>`;
+      });
+      const c = r && r.entries[0], o = r && r.entries[1];
+      h += `<td>${ok(c) && ok(o) ? (same(c, o) ? '<span class="sm">tie</span>' : (c[0] / o[0]).toFixed(2) + "×") : ""}</td></tr>`;
+    });
+    return `<div class="tb"><table>${h}</table></div>`;
+  }
+
+  function foot(b) {
+    const shard = M.shards.find((x) => x.shard === b.shard) || {};
+    const parts = [`Ran on ${esc(cpu(shard.cpu))}${M.shards_total > 1 ? `, shard ${b.shard + 1} of ${M.shards_total}` : ""}`];
+    if (b.variation != null) parts.push(`<span class="${b.noisy ? "noisy" : ""}">${esc(nice(REF))} ran ${b.reference_passes} times; its i/s varied by ${(b.variation * 100).toFixed(1)}%${b.noisy ? " (noisy)" : ""}</span>`);
+    return `<div class="rfoot">${parts.map((p) => `<span>${p}</span>`).join("")}</div>`;
+  }
+
+  const open = new Set();
+  function render() {
+    if (mode && !has(mode)) mode = "";
+    $("rmodes").innerHTML = MODES.map(([m, name]) => `<button type="button" class="chip" data-m="${m}" aria-pressed="${m === mode}" ${has(m) ? "" : 'disabled title="Not built in this run"'}>${name}</button>`).join("");
+    $("rshow").innerHTML = SHOWS.map(([k, name]) => `<button type="button" class="chip" data-s="${k}" aria-pressed="${k === showing}">${esc(name)}</button>`).join("");
+    $("rhint").textContent = mode ? "Dashed: the same Rubies without the JIT, on the same machine." : "";
+    let h = "", sec = null;
+    B.forEach((b, n) => {
+      if (b.section !== sec) { sec = b.section; h += `<h2>${esc(sec)}<span class="on">${esc(MODES.find(([m]) => m === mode)[1])}</span></h2>`; }
+      const legend = b.names.map((nm, i) => `<span><i style="background:${color(i)}"></i><code>${esc(nm)}</code>${i ? "" : " (claimed)"}</span>`).join("") + (mode ? '<span class="ghost"><i></i>without the JIT</span>' : "");
+      h += `<article class="rcard"><h3>${md(b.title)}</h3><p class="say">${summary(b)}</p><div class="rlegend">${legend}</div>` +
+        `<div class="chart" data-n="${n}"></div>${foot(b)}` +
+        `<details data-n="${n}"${open.has(n) ? " open" : ""}><summary>Numbers per build</summary>${table(b)}</details>` +
+        `<div class="links"><a href="${M.repo}/blob/main/${encodeURI(b.file)}">View the code</a></div></article>`;
+    });
+    $("rout").innerHTML = h;
+    if (!$("view-across-rubies").hidden) $("rout").querySelectorAll(".chart").forEach((c) => chart(B[+c.dataset.n], c));
+  }
+
+  $("rmodes").addEventListener("click", (e) => { const c = e.target.closest(".chip"); if (c && !c.disabled) { mode = c.dataset.m; window.SiteViews.setParams({ build: mode || null }, true); render(); } });
+  $("rshow").addEventListener("click", (e) => { const c = e.target.closest(".chip"); if (c) { showing = c.dataset.s; window.SiteViews.setParams({ show: showing === "rel" ? "rel" : null }, true); render(); } });
+  $("rout").addEventListener("toggle", (e) => { const d = e.target; if (d.matches("details")) d.open ? open.add(+d.dataset.n) : open.delete(+d.dataset.n); }, true);
+  window.addEventListener("popstate", () => { fromURL(); render(); });
+  // Charts are drawn only when the view is shown, at the width it has then.
+  document.addEventListener("viewchange", (e) => { if (e.detail === "across-rubies") { fromURL(); render(); } });
+  let resizing;
+  window.addEventListener("resize", () => { clearTimeout(resizing); resizing = setTimeout(() => { if (!$("view-across-rubies").hidden) render(); }, 150); });
+  // The first render comes from SiteViews.show() below, once this view is visible.
+  fromURL();
+})();
+// Both views have run; show the chosen one (and draw its charts).
+window.SiteViews.show();
+</script>
 </body>
 </html>

From 733b8c381b1271b645315931bc26ea51a87a0e8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20V=C3=A1squez?= <juan@ombulabs.com>
Date: Tue, 6 Oct 2026 13:43:36 -0600
Subject: [PATCH 5/6] Step 5: Publish the site from the weekly run only

Results site now builds the site from its six shards and deploys it, only
for a complete run on main. Before deploying it checks the last successful
run: if that run is newer (a re-run of an old run, or two runs finishing
out of order), it does not publish over its results.

benchmarks.yml goes back to checking that every benchmark runs on every
Ruby: no site preview and no result files, which nothing reads any more.
Each workflow now does one thing, and the site has one source.

A merged benchmark reaches the site with the next weekly run, or sooner by
running Results site by hand.
---
 .github/workflows/benchmarks.yml   | 114 ++---------------------------
 .github/workflows/results-site.yml |  52 +++++++++++++
 compose.yaml                       |   1 -
 docker/collect_results.rb          |   1 -
 4 files changed, 59 insertions(+), 109 deletions(-)

diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
index d9a7914..636015f 100644
--- a/.github/workflows/benchmarks.yml
+++ b/.github/workflows/benchmarks.yml
@@ -1,5 +1,7 @@
 name: Benchmarks
 
+# Checks that every benchmark runs on every Ruby (PRs: only the files they change).
+# It publishes nothing: the results site comes from results-site.yml.
 # Always runs, so the benchmarks-ok check at the end always reports and can be
 # required. The changes job decides whether there is anything to benchmark.
 on:
@@ -67,14 +69,12 @@ jobs:
           - { ruby: ruby_4.0, variant: zjit, flags: --zjit }
           - { ruby: ruby_head, variant: zjit, flags: --zjit }
 
-    # Read by docker/run-benchmarks.sh and docker/collect_results.rb.
     env:
+      # Read by docker/run-benchmarks.sh.
       RUBY_VARIANT: ${{ matrix.variant }}
       RUBY_VARIANT_FLAGS: ${{ matrix.flags }}
-      RESULTS_DIR: results
-      RESULTS_COMMIT: ${{ github.event.pull_request.head.sha || github.sha }}
-      RESULTS_PR: ${{ github.event.pull_request.number }}
-      RESULTS_LABEL: ${{ matrix.ruby }}${{ matrix.variant && format('+{0}', matrix.variant) || '' }}
+      # The build's name in the step names and the failure report, for example ruby_3.4+yjit.
+      BUILD: ${{ matrix.ruby }}${{ matrix.variant && format('+{0}', matrix.variant) || '' }}
 
     steps:
       # Plain Rubies only: shared reports do not record the Ruby or its flags,
@@ -84,113 +84,13 @@ jobs:
         run: |
           echo "SHARE=1" >> "$GITHUB_ENV"
       - uses: actions/checkout@v4
-      - name: Run benchmarks on ${{ env.RESULTS_LABEL }}
+      - name: Run benchmarks on ${{ env.BUILD }}
         env:
           FILES: ${{ needs.changes.outputs.files }}
         run: .github/scripts/run-benchmarks.sh ${{ matrix.ruby }}
       - name: Report failed benchmarks
         if: failure()
-        run: .github/scripts/report-failures.sh benchmarks.log ${{ env.RESULTS_LABEL }}
-      - name: Upload results
-        uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: results-${{ env.RESULTS_LABEL }}
-          path: results/
-          if-no-files-found: warn
-
-  # Builds the results site from every job's results, also when some jobs
-  # failed, so a PR gets a preview (the site-preview artifact, named outside
-  # the results-* pattern so a re-run never downloads it). Skipped when the
-  # benchmark jobs did not run (a lint failure). Only a push to
-  # main where every job passed publishes it, so a partial run never replaces
-  # the live site. Not required: a Pages problem never blocks a merge.
-  site:
-    needs: [changes, rake]
-    if: ${{ !cancelled() && needs.changes.outputs.run == 'true' && needs.rake.result != 'skipped' }}
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: results-*
-          path: results/
-          merge-multiple: true
-      - name: Build the results site
-        # A failed benchmark job leaves no result file, like a benchmark that needs a newer Ruby, so the page says missing results may be crashes.
-        env:
-          RESULTS_INCOMPLETE: ${{ needs.rake.result != 'success' && '1' || '' }}
-        run: docker compose run --rm -T -e RESULTS_INCOMPLETE --entrypoint ruby ruby_4.0 script/build_results_site.rb results _site
-      - name: Upload the site preview
-        id: preview
-        uses: actions/upload-artifact@v4
-        with:
-          name: site-preview
-          path: _site/
-          # A re-run replaces the earlier attempt's preview.
-          overwrite: true
-      # A one-click link on the run's Summary page; it needs no extra permissions, so it works for PRs from forks too.
-      - name: Link the site preview in the run summary
-        env:
-          PREVIEW_URL: ${{ steps.preview.outputs.artifact-url }}
-        run: |
-          {
-            echo "### Results site preview"
-            echo ""
-            echo "[Download the site preview]($PREVIEW_URL) (a zip, needs a GitHub login), unzip it and open \`index.html\` in a browser."
-          } >> "$GITHUB_STEP_SUMMARY"
-      - name: Upload the site for GitHub Pages
-        if: github.event_name == 'push' && github.ref_name == 'main' && needs.rake.result == 'success'
-        uses: actions/upload-pages-artifact@v5
-        with:
-          path: _site/
-
-  deploy:
-    needs: [rake, site]
-    if: github.event_name == 'push' && github.ref_name == 'main' && needs.rake.result == 'success' && needs.site.result == 'success'
-    runs-on: ubuntu-latest
-    # Only this job can publish; the rest of the workflow keeps the default
-    # token permissions.
-    permissions:
-      pages: write
-      id-token: write
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    # One deploy at a time; a newer merge waits instead of cancelling one that
-    # is halfway through.
-    concurrency:
-      group: pages
-      cancel-in-progress: false
-
-    steps:
-      # Runs can finish out of order, so an older run must not put its results back over a newer one.
-      # When main moved on, ask pick-benchmarks.sh (the same rule CI uses) whether the newer commits run benchmarks.
-      # If they do, their own run deploys newer results; if not (a README-only merge), this run's results are still the newest.
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          fetch-depth: 0
-      - name: Check no newer run on main will deploy
-        id: newest
-        run: |
-          if [ "$(git rev-parse HEAD)" = "$GITHUB_SHA" ]; then
-            echo "deploy=true" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-          GITHUB_EVENT_NAME=push GITHUB_OUTPUT=newer.txt .github/scripts/pick-benchmarks.sh "$GITHUB_SHA"
-          if grep -q '^run=true' newer.txt; then
-            echo "main moved on and its newer commits run benchmarks, so their run deploys; skipping."
-            echo "deploy=false" >> "$GITHUB_OUTPUT"
-          else
-            echo "main moved on, but nothing since this run affects benchmarks; deploying."
-            echo "deploy=true" >> "$GITHUB_OUTPUT"
-          fi
-      - name: Deploy to GitHub Pages
-        id: deployment
-        if: steps.newest.outputs.deploy == 'true'
-        uses: actions/deploy-pages@v5
+        run: .github/scripts/report-failures.sh benchmarks.log ${{ env.BUILD }}
 
   # The check to require on main. Passes when every benchmark job passed, or
   # when there was nothing to benchmark.
diff --git a/.github/workflows/results-site.yml b/.github/workflows/results-site.yml
index d44fa49..0dee86a 100644
--- a/.github/workflows/results-site.yml
+++ b/.github/workflows/results-site.yml
@@ -41,3 +41,55 @@ jobs:
           # A re-run of a failed shard replaces its earlier attempt.
           overwrite: true
 
+  # Builds both views from all six shards and publishes them, only for a complete run on main.
+  site:
+    needs: shard
+    if: github.ref_name == 'main'
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+      # Reads this workflow's earlier runs (the newest-results check below).
+      actions: read
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    # One deploy at a time; a newer run waits instead of cancelling one that is halfway through.
+    concurrency:
+      group: pages
+      cancel-in-progress: false
+
+    steps:
+      - uses: actions/checkout@v4
+      # Never put older results back: a re-run of an old run, or two runs finishing out of order, must not publish over a newer run's results.
+      # Run ids only grow and a re-run keeps its id, so a newer run has a higher id (and, since main cannot be force-pushed, a commit at least as new).
+      - name: Check no newer results are live
+        id: newest
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          live=$(gh run list --workflow results-site.yml --branch main --status success --limit 1 --json databaseId --jq '.[0].databaseId // empty')
+          if [ -n "$live" ] && [ "$live" -gt "$GITHUB_RUN_ID" ]; then
+            echo "The live site has results from run $live, newer than this run ($GITHUB_RUN_ID); not publishing."
+            echo "publish=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "publish=true" >> "$GITHUB_OUTPUT"
+          fi
+      - uses: actions/download-artifact@v4
+        if: steps.newest.outputs.publish == 'true'
+        with:
+          pattern: results-shard-*
+          path: results/
+          merge-multiple: true
+      - name: Build the results site
+        if: steps.newest.outputs.publish == 'true'
+        run: docker compose run --rm -T --entrypoint ruby ruby_4.0 script/build_results_site.rb results _site
+      - name: Upload the site for GitHub Pages
+        if: steps.newest.outputs.publish == 'true'
+        uses: actions/upload-pages-artifact@v5
+        with:
+          path: _site/
+      - name: Deploy to GitHub Pages
+        id: deployment
+        if: steps.newest.outputs.publish == 'true'
+        uses: actions/deploy-pages@v5
diff --git a/compose.yaml b/compose.yaml
index 24723c4..75b5448 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -20,7 +20,6 @@ x-benchmark: &benchmark
     - RESULTS_DIR
     - RESULTS_LABEL
     - RESULTS_COMMIT
-    - RESULTS_PR
     # Cross-Ruby runs only (script/run_cross_ruby.rb).
     - RESULTS_SHARD
     - RESULTS_SHARDS
diff --git a/docker/collect_results.rb b/docker/collect_results.rb
index 9d642fc..ef11bd8 100644
--- a/docker/collect_results.rb
+++ b/docker/collect_results.rb
@@ -48,7 +48,6 @@ def write(report)
         "flags" => env("RUBY_VARIANT_FLAGS"),
         "jit" => jit,
         "commit" => env("RESULTS_COMMIT"),
-        "pr" => env("RESULTS_PR") && env("RESULTS_PR").to_i,
         "run_id" => env("GITHUB_RUN_ID"),
         "run_attempt" => env("GITHUB_RUN_ATTEMPT"),
         "runner" => env("RUNNER_NAME"),

From ae143433833a8326d71a973e0df5a6ae90b59aa2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20V=C3=A1squez?= <juan@ombulabs.com>
Date: Tue, 6 Oct 2026 13:43:36 -0600
Subject: [PATCH 6/6] Step 6: Explain the results site and the two workflows

CONTRIBUTING: how to run a few benchmarks on a few builds and build the
site from them, which builds to leave out on an Apple silicon Mac, and
what each workflow does.
---
 .gitignore      |  1 +
 CONTRIBUTING.md | 25 ++++++++++++++-----------
 2 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/.gitignore b/.gitignore
index da0fa2b..6dfcfa6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@
 /Gemfile.lock
 /results/
 /_site/
+/cross-ruby/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 762b82c..74d4260 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -12,6 +12,7 @@ These idioms list here are trying to satisfy following goals:
 
 - [Note on entry](#note-on-entry)
 - [Running it on other Rubies](#running-it-on-other-rubies)
+- [The results site](#the-results-site)
 - [Benchmarks that need a newer Ruby](#benchmarks-that-need-a-newer-ruby)
 - [License](#license)
 
@@ -104,23 +105,25 @@ RUBY_VARIANT=yjit RUBY_VARIANT_FLAGS=--yjit docker compose run --rm ruby_3.4 cod
 RUBY_VARIANT=zjit RUBY_VARIANT_FLAGS=--zjit docker compose run --rm ruby_4.0 code/your-new/entry.rb
 ```
 
-To keep the results, set `RESULTS_DIR`. Each benchmark then also writes its
-report as JSON to `results/<label>/`, with the Ruby, its flags and the machine
-it ran on:
+## The results site
+
+The results site (https://fastruby.github.io/fast-ruby/) compares Rubies, so every build of a benchmark has to run on the same machine.
+`script/run_cross_ruby.rb` (Ruby 3 on your machine, it calls Docker) does that, and runs the newest released MRI again after every 3 builds, so the site can show how steady the machine was.
+To see a few benchmarks the way the site shows them, run them on a few builds, build the site into `_site/`, then open `_site/index.html` in a browser:
 
 ```
-RESULTS_DIR=results RESULTS_LABEL=ruby_3.4 docker compose run --rm ruby_3.4 code/your-new/entry.rb
+ruby script/run_cross_ruby.rb --files code/date/iso8601-vs-parse.rb,code/string/gsub-vs-tr.rb --builds ruby_3.4,ruby_3.4+yjit,ruby_4.0 --out cross-ruby
+docker compose run --rm -T --entrypoint ruby ruby_4.0 script/build_results_site.rb cross-ruby _site
 ```
 
-To see those results the way the results site shows them, build the site
-into `_site/`, then open `_site/index.html` in a browser:
+`ruby script/run_cross_ruby.rb --help` lists the options.
+The builds are the ones in the CI matrix (`.github/workflows/benchmarks.yml`), so a new Ruby added there and in `compose.yaml` is measured too, and once released it becomes both the reference and the Ruby the site opens on.
+On an Apple silicon Mac, leave out `ruby_2.1` and `jruby_9.1` (they run under emulation, so their numbers are not comparable) and `ruby_3.1+yjit` (Ruby 3.1's YJIT only exists on x86-64).
 
-```
-docker compose run --rm -T --entrypoint ruby ruby_4.0 script/build_results_site.rb results _site
-```
+CI has two workflows:
 
-CI does the same after every run: the site is attached to the run as the
-`site-preview` artifact, and published to GitHub Pages from `main`.
+- `.github/workflows/benchmarks.yml` checks that every benchmark runs on every Ruby: on a PR, the benchmark files it changes; on `main`, all of them when a benchmark or a shared file changed. It publishes nothing.
+- `.github/workflows/results-site.yml` runs every build on every file once a week, split over 6 machines, and publishes the site. Run it by hand from the Actions tab to publish sooner.
 
 ## Benchmarks that need a newer Ruby