From 274e0b987f509d6734a047563a2c8e58f1c5fa5f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 5 Aug 2026 05:07:38 +0000
Subject: [PATCH 1/7] perf: cut Ruby<->C++ conversion overhead in tensor and
 forward paths

Adds a benchmark suite (bench/) and fixes what it found.

The suite converts .pt checkpoints to .pte, runs them through the gem,
checks the output against PyTorch's, and times each leg of an inference
call separately. Models span three regimes so binding cost is visible
where it matters (tiny models) and honestly negligible where it doesn't.

What the profile showed: on tiny_mlp, 76% of an inference call was not
inference. Root cause is that Rice routes every element access and every
scalar conversion through detail::protect(), i.e. an rb_protect() -- a VM
tag push plus setjmp -- so reading one Float out of an Array cost two of
them, and writing one cost another. At ~0.6us in and ~1.1us out per
element, a 150k-element resnet18 input took 92ms to build before any math
happened.

Changes:

- utils.h: inline conversion helpers that take the fast path for Float and
  Fixnum and fall back to Rice's protected call only for cases that can
  actually raise or run Ruby code. Array building uses rb_ary_new_capa +
  rb_ary_push on an array that cannot raise.
- Tensor.create / to_a: use those helpers. 13x faster in, up to 65x out.
- Tensor.from_bytes / Tensor#to_binary: new opt-in raw-buffer path that
  skips per-element conversion entirely. 150k-element input: 92ms -> 0.5ms.
- Model#forward / #execute: stop deep-copying every input tensor on every
  call (the caller's Array holds it live for the duration, so the copy
  bought nothing), dispatch on type instead of catching Rice's conversion
  exception, and reuse the EValue buffer across calls.
- lib/executorch.rb: flatten nested input level-by-level with Array#concat
  instead of a recursive flat_map that allocated an intermediate Array per
  leaf. 153,238 allocations -> 11 for a resnet18 input, and jagged-array
  detection is preserved.
- utils.h / executorch.cpp: collapse three copies of the error-code switch
  into one error_name().
- extconf.rb-adjacent: Object input = inputs[i] no longer compiles against
  Rice 4.12 (Array::Proxy lost its implicit conversion); construct
  explicitly from .value().

Binding overhead on mlp_512x2 goes from 23.3% of an end-to-end call to
1.1%. All 59 existing tests pass, and every model's output still matches
PyTorch to within 1e-4.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACSJ1DPT6ryZy6gdvnaJ5K
---
 .gitignore                                    |   6 +
 bench/README.md                               | 113 +++
 .../__pycache__/bench_models.cpython-311.pyc  | Bin 0 -> 6610 bytes
 bench/bench_models.py                         |  92 +++
 bench/compare.rb                              |  52 ++
 bench/make_pt_models.py                       | 132 ++++
 bench/pt_to_pte.py                            | 103 +++
 bench/results/baseline.json                   | 537 +++++++++++++
 bench/results/optimized.json                  | 726 ++++++++++++++++++
 bench/run_bench.rb                            | 238 ++++++
 ext/executorch/executorch.cpp                 | 395 +++++-----
 ext/executorch/utils.h                        | 162 +++-
 lib/executorch.rb                             |  97 +--
 13 files changed, 2368 insertions(+), 285 deletions(-)
 create mode 100644 bench/README.md
 create mode 100644 bench/__pycache__/bench_models.cpython-311.pyc
 create mode 100644 bench/bench_models.py
 create mode 100644 bench/compare.rb
 create mode 100644 bench/make_pt_models.py
 create mode 100644 bench/pt_to_pte.py
 create mode 100644 bench/results/baseline.json
 create mode 100644 bench/results/optimized.json
 create mode 100644 bench/run_bench.rb

diff --git a/.gitignore b/.gitignore
index 9097d09..0514744 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,9 @@ test/support/models/*.pte
 
 # Coverage
 /coverage/
+
+# Benchmark artifacts (regenerate with bench/make_pt_models.py + bench/pt_to_pte.py)
+/bench/models/
+/bench/results/*.json
+!/bench/results/baseline.json
+!/bench/results/optimized.json
diff --git a/bench/README.md b/bench/README.md
new file mode 100644
index 0000000..cfcd338
--- /dev/null
+++ b/bench/README.md
@@ -0,0 +1,113 @@
+# executorch-ruby benchmarks
+
+An eval + profiling harness for the gem. It answers two questions:
+
+1. **Are we right?** Does Ruby produce the same numbers PyTorch does?
+2. **Where does the time go?** How much of an inference call is actual
+   inference, and how much is the Ruby ↔ C++ boundary?
+
+## The pipeline
+
+```
+bench_models.py     model definitions (shared by both scripts below)
+      │
+      ▼
+make_pt_models.py   → models/<name>.pt         eager module, torch.save
+                    → models/<name>.meta.json  shapes, param count, eager latency
+                    → models/<name>.io.bin     golden input + output, raw float32
+      │
+      ▼
+pt_to_pte.py        → models/<name>.pte        torch.export → to_edge → to_executorch
+      │
+      ▼
+run_bench.rb        → results/<label>.json     eval + per-phase timings
+      │
+      ▼
+compare.rb          baseline vs current, phase by phase
+```
+
+## Running it
+
+```bash
+# 1. Build the .pt benchmarks (needs torch; torchvision for resnet/mobilenet)
+python3 bench/make_pt_models.py --all
+
+# 2. Convert every checkpoint to .pte
+python3 bench/pt_to_pte.py bench/models/*.pt
+
+# 3. Eval + profile
+bundle exec ruby bench/run_bench.rb --label mine
+
+# 4. Compare against a stored run
+bundle exec ruby bench/compare.rb bench/results/baseline.json bench/results/mine.json
+```
+
+`pt_to_pte.py` works on any `.pt` you have, not just these:
+
+```bash
+python3 bench/pt_to_pte.py my_model.pt --input-shape 1,3,224,224 -o my_model.pte
+```
+
+(It calls `torch.load`, which unpickles arbitrary code — only point it at
+checkpoints you trust.)
+
+## The model set
+
+Chosen to span three regimes, because binding overhead only shows up in one of
+them:
+
+| model | input | regime | why it's here |
+|---|---|---|---|
+| `add_mul` | `[1,3]` | overhead | `x*2+1`, the README example. Almost no math — nearly all of the wall time is the boundary. |
+| `tiny_mlp` | `[1,8]` | overhead | Smallest real layer. Same idea. |
+| `mlp_512x2` | `[1,512]` | mixed | Enough math to matter, small enough that per-call cost still shows. |
+| `mnist_cnn` | `[1,1,28,28]` | mixed | Convolutions, small input. |
+| `mlp_1024x4` | `[1,1024]` | compute | 4.2M params — kernels dominate. |
+| `resnet18` | `[1,3,224,224]` | compute | Real vision model, 150k-element input. |
+| `mobilenet_v2` | `[1,3,224,224]` | compute | Same, depthwise-separable. |
+
+## Reading the output
+
+Each model reports an eval line and one row per phase:
+
+```
+tiny_mlp  [overhead]  in=[1, 8] out=[1, 8] params=72
+  eval: PASS  max_abs_error=5.96e-08  (pytorch eager p50 0.010 ms)
+  phase                  p50 ms     p90 ms    allocs/call
+  tensor_new_flat        0.0150     0.0170            1.0
+  ...
+  binding overhead: 73.9% of e2e is not forward()
+```
+
+The phases:
+
+| phase | what it measures |
+|---|---|
+| `tensor_new_flat` | `Tensor.new(flat_array, shape:)` |
+| `tensor_new_nested` | `Tensor.new(nested_array)` — shape inferred, the README's style |
+| `forward` | `model.predict([t])` with the tensor already built |
+| `to_a_flat` | `Tensor#flat_to_a` |
+| `to_a_nested` | `Tensor#to_a` — reshaped to match `shape` |
+| `e2e` | build → predict → read, the way an app calls it |
+| `tensor_from_bytes` | `Tensor.from_bytes(packed, shape:)` — the memcpy path |
+| `to_binary` | `Tensor#to_binary` — the memcpy path out |
+| `e2e_binary` | round trip using packed bytes at both ends |
+
+`allocs/call` comes from `GC.stat`. It is often the more useful number: object
+churn on this boundary is usually what the latency is made of.
+
+Timings are batched — each sample runs the block enough times to span ~500 µs —
+so a per-call cost of a few microseconds isn't swamped by the cost of reading
+the clock. Phases stop early once they've spent `--budget-s` (default 3 s), so
+a slow model doesn't stall the suite.
+
+## Caveats
+
+- `eager_p50_ms` in the metadata is PyTorch's own latency for the same
+  checkpoint, measured on the machine that generated it. It's a sanity anchor,
+  not a like-for-like comparison — a different machine, or one busy compiling,
+  will skew it. Regenerate the models to refresh it.
+- Absolute numbers are machine-specific. The *ratios between phases* are the
+  durable finding.
+- `forward` speed depends heavily on which kernels the runtime was built with;
+  see the "Kernels" section in `bench/FINDINGS.md`.
diff --git a/bench/__pycache__/bench_models.cpython-311.pyc b/bench/__pycache__/bench_models.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5e36ac5ff313c66602b539612348fc824a7beb5
GIT binary patch
literal 6610
zcmcIoU2GKB6~43oUax<#!5EBg(j>69F#&=aNJ>kA5E|Pdm;`W$mhsNmJ7ITbxijm(
z7}csGbwO@JB~nb~s#YH;2rBiV@6BVMs&!?l)<~$4`edmOMo<amso%M?yWaK2C{mI;
zJ7@3Qd*<A8&)+>~{?yPAWoUo>oA}tRXY4=pP-=C>&XZ<^vD-{z!%R~&Us@Sf<i9WD
zANDKE$4)WL|0&Y~y8q)q>E*kA#vb7I+Hg=}1%VZM4pvBFg@F}$4pvxV)d4H|9IS{|
z|0x@;(_+AD&>BbmS`&KBve$xMtF{GWZRoXYThZHwUWXjpj$Wr6+fnZATnG<G$C%dj
zM`gHP^9`~1F7+Qi#s(}+PjgKlHB7@XEYs#WTi5u=6n9cO*C+L4&ap%?wO8aYHlmx!
zR7Mq7xScZ`y)PO)mojXgv9w%T=ja)ktR)<ez=-9f_~pwP^@^UzItd`@X}d2wb@?*i
zGm$cqDV{ZwSJJvoOGP~zpkO){-s;Obz#BC%9p|d4VF)xF3zYOK8acCqN+#aRZA;Qi
zrd8Vp?M%*gc-k1(c}f>L7b+GLz)(#r1*(ZeMm5Yt0;}!ai)XppK3g5vF=Clq<r66@
zUE+`1m<Lsr3w;#y%%sl2FUiW2p*dEPMiwhc0qLHwfRHvubTFW&r?{O}A!{ckbnv8)
z85!L^5{-6)0c%_rDP7e(hOnEo;W&_P2K0z;hfk>KG<Wa{NnEosh6$Qwot-5`y}9=&
zKi<<5<$T1-nVKr5`uMq&ZtGly5Qtq*9Ueh&l;%@b4qMfW;?entVQPjshP~pAG0W2W
zBzqZSQYYTfATOb-X+B|zE4_Rq=Wshitm&qe8!Pgf)y3W<4VJbA2^x5`Q`Us-QA}Ey
zY|bHZ6Gh_fiY`ppN_lT@l$ha33);lHxwOW|RnxFjp23)wVZ$6($y*1LMW>a2aDCaH
zbl~qc(;1wf4f`}@*suBEU;)h!X9&2VW12RQOHUt#m^|U|QDJ2yKW9%KJ27zb2$VC)
zyZHg$!}r5N`I#IfQ{GorSR;C05<XRK)Ta>gq!r*cn?cx_4l<_srtyqb{e!E7vPwMO
zXZL+>z}C~Ft}<!UFy~*rx-VsA^nGwiv2TMf?vuXg!FAtq!=sj%P=z+#=<TPk_`D4S
z?Ph>kw$jvmbN}_+&8yd^3XzT{7-NI+pc_dfOf{n?5^fYeAw3%XSR!#Xr>2WD;Y32S
zl8J<9z)K=Rppig~0EJEo+R(A%0JG(5CGd73@b+3j32t9wwZNl71gdmLvZMCo6@Xt>
zYA=vyqX^}n)<KI1-NSgEREC3)Y0wRyGt8-h{xhq@UzI*+0jZA}bUs&ZGpA%7c)pAK
z0dB7?R?L*fHsUDEfi_F+;}W;f^NeyA8hk)nlx>D3Xl>avX#T!J5)axrxCaTIf-i*a
zGfg+tZ<x9&T;FIi?iX~p!77Yt-K|R`WK2sWY+8x)Sx@ZS@i5(7+;d-v)=rGtuL3-q
zWsf2a*TZw+e?>a}8R=MxbS_6a3z5!8t!=mB^CuQxT58?B+`2m-m<#7|NmW!yjaHLV
z>qQ4v%og!q+puTI>_J&>Lrjp-#T7xk2s(_5X6^A!CN$kt;=5?3oUq7S$V|6<HgRJD
zW;#7LU5IR#jDcD^X77hY6aEAlv}hqfQjk{ZHWcNQL{Lj4?ki#!rfg#CC*Hzjo`S#*
zn&=0Bj7ry<&llXY#x?^HCD=&@ygBepnaC$`mm3L?TCFJur78QRDF>=dIpq4ujFF%)
z5yHF45)mRq15zvhMd!P)<uP{6Uun-XzG{7*U?1(h7MSrnVOrj6>*-Rh%~#=-{iNE<
z#(dK-gKPe|zA9|mn`|@wU&G!K<rT?yJgbTbisw@8ZcwP^m@YbLfOP5x&g%W|yU`*2
zYECyDLruGWQ+MJa=}w}HP=cDCby999txoB}c9n!@CbTlAR_R<ZXrb&_F9X9)0c`46
zD=k~{p+_xSZ{~ip^VUvSOWk1!^2b(Ut)GiqQ;Thj&eFEt<!!xx9(g!+-*{*gw!Xd;
zdp-YF{;fw_+Hd`6@s+}sI2<yP$MropWH;E~#3AcxuSI7hf3I-H$s3dN%Jom?K0)yC
zoY5yp8qzier{0V7Mun@rM1utAu64CwuzQVd1{#&%4sx~4f#+&Oy2{l`QTNFn%v7Bk
zIP;6=Mug6NI2)V~=SE0o0FeRY6VCC$!Rf<8GLK1G<~WDpP@+g_iJeljIPgd1gN(&S
zk`D}?9y*6aS<PhAIR4Aw4{M_y@mzEPqu+&#R=Vf<aZ@!Kz?!mAg`@d3<ze71#vYW%
ztFSk5%PO3*Git%=fKY{1rjJ!a-|xD2!O?><SC!$RiX%GxJxPSMNX>Cvstr*ULiu%r
zf?~`nohPdlRpW{q&Z-(Ez|y=|IR*`mRafaqjz`zSj~90+-El+5VKE0ZL5Ann4XBf6
zEGvCLb0ed=>L6LPz3>$EY-iNaMcn7bBzZ=W;Z_BnmXbx5qt8L0*mnRnjXsY$Iu{xq
z#Tw^M-&E&Y=ij@h6k^>=vF_zqH;taUetPaSb^7O9uD?6?u7^1?|KhxQucZ*{S&H>6
z$9ldF^KnCXd-N#-KxAt8Uo+d$wGdzY*<XB1od=gY4`Q$>kE=FZk&(%hY6hKeo<Ceu
zkZDx96W;dPjIvnr@zRj|*EVDz)#eH{`#d!xuR4qu#1Q}_%xTqebaRt<*j!dYF)02R
zFWLJ5kfFqyKO49)F#p0*Z0B-pXI`O{<>xnkK7aKOQ@@+K*K%iOVP>hRce$yz5b5<I
zW_V-XLb=X*@*-ZK$Bj{x(l|kYZhHWrB4Jqx94`cpuLYvP*VfqAfDT`9FXc0v122pc
z?W*WiR$B@)w^^O{?Sy5NYl_0mmLD*u?DG`gML=N}QQ8c#2{!4!$R-pYt31?^Ah2pL
z)O-*9H7W{B|NEyo1Jxbs^PK4j)aEE{Wl=tE*!V!<)n>ii5-2|5R3;y^OjN?7Kv&0A
zBdv}g4o6Y>a(-Sn#!`+~!6HXMsZ14pHYc){tsjwLTuml(LQPKbWJ*t7L4BFYqTaQ+
ztfJL1EN?rKmO~#p5ayGPhnltUrNaB#P-JqVxY~rQPAwBvJ|YNLQN~V~X-h=`O-u>0
z-9ZX4#TQU~wpMJg&#TPcQ1QS1wEU)WQV2`9;W6ETxgu`30jkMdzcZexOsi3_RnQVA
zvDOLP_J;toY%S&wwyi|=6l#9Y9@TH9)3$9Lz?$<;-dXcw^x3m#U)Fd1>W4QE&Igw2
zyO!&_7PUfs&r*HQa(z!B&|}9y{}-V;c0Iby|6667zve`i5rD$n^Qx{=cBgp7B!zI#
zI*I&OkvG$7W<*nuic@$T!fjJ9o@KxP;Le4G3$q?BLMp{_L7~!(l*;oeeux*z4@ak(
zpN%oZiyBmOp!ATHLp4*96$#D(M~VUboL_wJ&hWzU29AhI6(8h4k`MCujeKanYIgxA
z{=xNx3x&-~cxz)3PLh%AypN7e#W~m+THLaz-uZCh!wn3*jA=J0zvz5RzE&CbvP%0A
z?-1BbNFQKwovXIRt9LFfT-w0ZAaNBgeif?Xi#$il>zmt=jGdctbDp><n$U$xg#|nl
zk~zUnAc?a8Rjd#jk`<25M%C3sHQ%5cK~zC5x&L)2j=XYH5naG!Nko_KbuV=tTJAbj
z5>b&cvhCF`i3$ny+c6f)SR?q%3f>aq2LzeTrmS7W<T`78OI?STyAGFF3%g;2yF@0J
zb|VhHz$7y1tXl_=IJE!3<N-HI-Tki~cy01E3{$F|NSdY~w-L1Gcu)|1F-(BMmH3Fj
zC4hKL&^hS_WoQF=`Xb$jm#O4)Lj&?-l@~Iki%Q3knkPxSk+UaHAxS@b(QQ0&@~va<
z_n%7)ynEtg|ImhwBEWdxy^abJDdiq^3J?)cQPzA7N??r<*u|8F*%)0bti4eETMGpg
zeB!DF`LlBuAJh2L^~uJNf)5F`AU`r^Jf`ud>yxc@3M!#mkbiM5{+Py}u1|KfC^+tG
zL0-&FJ*M%e>yvw;N-q+J64=GIzEWs^`QGRkorSjkmG<3*_TA-&J%#o?_flVME3}<n
zX^$7$<M)g&winvoDWaLhnL~y4Lxnfq`TNB}+xeCD!v*|`Pisw)m~V{%%tqGQSnGRA
Oq2&yIvyF7gQ2&2fH;0t~

literal 0
HcmV?d00001

diff --git a/bench/bench_models.py b/bench/bench_models.py
new file mode 100644
index 0000000..fc20a55
--- /dev/null
+++ b/bench/bench_models.py
@@ -0,0 +1,92 @@
+"""Model definitions used by the executorch-ruby benchmark suite.
+
+This module is imported by both ``make_pt_models.py`` (which pickles the
+modules into ``.pt`` files) and ``pt_to_pte.py`` (which unpickles them), so the
+classes must live here rather than in ``__main__`` -- ``torch.save`` on a whole
+module stores a reference to the defining module path.
+
+The suite deliberately spans three regimes:
+
+* ``overhead`` -- so little math that wall time is dominated by the Ruby <-> C++
+  boundary. These are the models that tell you whether the bindings are good.
+* ``mixed``    -- real work, but small enough that per-call overhead still shows.
+* ``compute``  -- the kernels dominate; binding cost should vanish into noise.
+"""
+
+import torch
+import torch.nn as nn
+
+
+class AddMul(nn.Module):
+    """The model from the README: ``x * 2 + 1``. Pure overhead probe."""
+
+    def forward(self, x):
+        return x * 2 + 1
+
+
+class TinyMLP(nn.Module):
+    def __init__(self, size=8):
+        super().__init__()
+        self.fc = nn.Linear(size, size)
+
+    def forward(self, x):
+        return self.fc(x)
+
+
+class MLP(nn.Module):
+    def __init__(self, size=512, depth=2):
+        super().__init__()
+        layers = []
+        for _ in range(depth):
+            layers += [nn.Linear(size, size), nn.ReLU()]
+        self.net = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class MnistCNN(nn.Module):
+    """Small conv net in the shape of the classic MNIST example."""
+
+    def __init__(self):
+        super().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(1, 16, 3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(16, 32, 3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        self.classifier = nn.Linear(32 * 7 * 7, 10)
+
+    def forward(self, x):
+        x = self.features(x)
+        return self.classifier(x.flatten(1))
+
+
+def _torchvision(name):
+    """Build an untrained torchvision model, or return None if unavailable.
+
+    Weights are random on purpose: the accuracy check compares Ruby against
+    this exact checkpoint, so trained weights would only add a download.
+    """
+    try:
+        import torchvision.models as tvm
+    except ImportError:
+        return None
+    return getattr(tvm, name)(weights=None)
+
+
+# name -> (builder, input shape, regime)
+REGISTRY = {
+    "add_mul":      (lambda: AddMul(),        (1, 3),            "overhead"),
+    "tiny_mlp":     (lambda: TinyMLP(8),      (1, 8),            "overhead"),
+    "mlp_512x2":    (lambda: MLP(512, 2),     (1, 512),          "mixed"),
+    "mlp_1024x4":   (lambda: MLP(1024, 4),    (1, 1024),         "compute"),
+    "mnist_cnn":    (lambda: MnistCNN(),      (1, 1, 28, 28),    "mixed"),
+    "resnet18":     (lambda: _torchvision("resnet18"),     (1, 3, 224, 224), "compute"),
+    "mobilenet_v2": (lambda: _torchvision("mobilenet_v2"), (1, 3, 224, 224), "compute"),
+}
+
+DEFAULT_MODELS = ["add_mul", "tiny_mlp", "mlp_512x2", "mnist_cnn", "mlp_1024x4"]
diff --git a/bench/compare.rb b/bench/compare.rb
new file mode 100644
index 0000000..f5b2fa3
--- /dev/null
+++ b/bench/compare.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Diff two bench result files.
+#
+#   bundle exec ruby bench/compare.rb bench/results/baseline.json bench/results/optimized.json
+#
+# Speedup is baseline/current, so 2.00x means the current run is twice as fast.
+
+require "json"
+
+base_path, cur_path = ARGV
+abort "Usage: ruby bench/compare.rb BASELINE.json CURRENT.json" unless base_path && cur_path
+
+base = JSON.parse(File.read(base_path))
+cur = JSON.parse(File.read(cur_path))
+
+PHASES = %w[
+  tensor_new_flat tensor_new_nested tensor_from_bytes
+  forward
+  to_a_flat to_a_nested to_binary
+  e2e e2e_binary
+].freeze
+
+puts "#{base['label']} -> #{cur['label']}"
+puts
+
+(base["models"].keys & cur["models"].keys).each do |name|
+  b = base["models"][name]
+  c = cur["models"][name]
+
+  puts "#{name}  [#{c['regime']}]"
+  puts format("  %-18s %12s %12s %9s %10s %10s",
+              "phase", "base ms", "cur ms", "speedup", "base allocs", "cur allocs")
+
+  PHASES.each do |phase|
+    bp = b["phases"][phase]
+    cp = c["phases"][phase]
+    next unless bp && cp
+
+    speedup = cp["p50_ms"].positive? ? bp["p50_ms"] / cp["p50_ms"] : 0.0
+    puts format("  %-18s %12.4f %12.4f %8.2fx %10.1f %10.1f",
+                phase, bp["p50_ms"], cp["p50_ms"], speedup,
+                bp["allocs_per_call"], cp["allocs_per_call"])
+  end
+
+  puts format("  binding overhead: %.1f%% -> %.1f%% of e2e",
+              b["binding_overhead_pct"], c["binding_overhead_pct"])
+  puts
+end
+
+only_cur = cur["models"].keys - base["models"].keys
+puts "only in #{cur['label']}: #{only_cur.join(', ')}" unless only_cur.empty?
diff --git a/bench/make_pt_models.py b/bench/make_pt_models.py
new file mode 100644
index 0000000..dbe2024
--- /dev/null
+++ b/bench/make_pt_models.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Produce the ``.pt`` benchmark checkpoints plus golden inputs/outputs.
+
+Each model in ``bench_models.REGISTRY`` becomes three files under
+``bench/models/``:
+
+    <name>.pt        eager nn.Module, pickled with torch.save
+    <name>.meta.json shapes, dtypes, regime, and the eager reference latency
+    <name>.io.bin    golden input followed by golden output, raw float32 LE
+
+The ``.bin`` sidecar keeps the Ruby harness honest: it compares its own output
+against numbers PyTorch produced, and reading raw floats costs nothing next to
+parsing a 150k-element JSON array.
+
+Usage:
+    python3 bench/make_pt_models.py                    # default set
+    python3 bench/make_pt_models.py --models resnet18  # specific models
+    python3 bench/make_pt_models.py --all
+"""
+
+import argparse
+import json
+import os
+import struct
+import time
+
+import torch
+
+import bench_models
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+MODELS_DIR = os.path.join(HERE, "models")
+
+
+def write_floats(fh, tensor):
+    flat = tensor.detach().contiguous().flatten().tolist()
+    fh.write(struct.pack(f"<{len(flat)}f", *flat))
+
+
+def time_eager(model, example, iters=30):
+    """Reference latency: the same model, same input, run by PyTorch itself."""
+    with torch.no_grad():
+        for _ in range(5):
+            model(example)
+        samples = []
+        for _ in range(iters):
+            t0 = time.perf_counter()
+            model(example)
+            samples.append((time.perf_counter() - t0) * 1000.0)
+    samples.sort()
+    return samples[len(samples) // 2]
+
+
+def build(name, out_dir):
+    builder, shape, regime = bench_models.REGISTRY[name]
+
+    # Seed before constructing so a model's weights (and therefore its golden
+    # output) are the same whether you build one model or all of them.
+    torch.manual_seed(0)
+    model = builder()
+    if model is None:
+        print(f"  skip {name}: torchvision not installed")
+        return None
+
+    model.eval()
+    example = torch.randn(*shape)
+
+    with torch.no_grad():
+        expected = model(example)
+    if not isinstance(expected, torch.Tensor):
+        raise TypeError(f"{name}: expected a single tensor output, got {type(expected)}")
+
+    eager_ms = time_eager(model, example)
+
+    pt_path = os.path.join(out_dir, f"{name}.pt")
+    torch.save(model, pt_path)
+
+    with open(os.path.join(out_dir, f"{name}.io.bin"), "wb") as fh:
+        write_floats(fh, example)
+        write_floats(fh, expected)
+
+    meta = {
+        "name": name,
+        "regime": regime,
+        "input_shape": list(example.shape),
+        "output_shape": list(expected.shape),
+        "input_numel": example.numel(),
+        "output_numel": expected.numel(),
+        "dtype": "float",
+        "params": sum(p.numel() for p in model.parameters()),
+        "eager_p50_ms": round(eager_ms, 4),
+        "torch_version": torch.__version__,
+    }
+    with open(os.path.join(out_dir, f"{name}.meta.json"), "w") as fh:
+        json.dump(meta, fh, indent=2)
+
+    print(
+        f"  {name:14s} {str(list(example.shape)):18s} "
+        f"params={meta['params']:>9,d}  eager p50={eager_ms:7.3f} ms  -> {pt_path}"
+    )
+    return meta
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--models", nargs="*", help="model names (default: the standard set)")
+    ap.add_argument("--all", action="store_true", help="build every registered model")
+    ap.add_argument("--out", default=MODELS_DIR)
+    args = ap.parse_args()
+
+    if args.all:
+        names = list(bench_models.REGISTRY)
+    elif args.models:
+        names = args.models
+    else:
+        names = bench_models.DEFAULT_MODELS
+
+    unknown = [n for n in names if n not in bench_models.REGISTRY]
+    if unknown:
+        raise SystemExit(
+            f"unknown model(s): {', '.join(unknown)}\n"
+            f"available: {', '.join(bench_models.REGISTRY)}"
+        )
+
+    os.makedirs(args.out, exist_ok=True)
+    print(f"Writing .pt benchmarks to {args.out}")
+    for name in names:
+        build(name, args.out)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/bench/pt_to_pte.py b/bench/pt_to_pte.py
new file mode 100644
index 0000000..713843a
--- /dev/null
+++ b/bench/pt_to_pte.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Convert a PyTorch ``.pt`` checkpoint into an ExecuTorch ``.pte`` program.
+
+This is the whole `.pt` -> `.pte` story in one place:
+
+    torch.load  ->  torch.export.export  ->  to_edge  ->  to_executorch
+
+``torch.export`` traces the module into an ATen graph with static shapes, which
+is why an example input is required; ``to_edge`` lowers that graph to the Edge
+dialect (the op set the ExecuTorch runtime knows); ``to_executorch`` serializes
+it into the flatbuffer that ``Executorch::Model.new`` mmaps.
+
+Usage:
+    # shapes read from the sidecar written by make_pt_models.py
+    python3 bench/pt_to_pte.py bench/models/tiny_mlp.pt
+
+    # or supply them yourself for any .pt you have lying around
+    python3 bench/pt_to_pte.py my_model.pt --input-shape 1,3,224,224 -o my_model.pte
+
+Note: ``torch.load`` unpickles arbitrary code. Only point this at checkpoints
+you produced or otherwise trust.
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+
+import torch
+from executorch.exir import to_edge
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)  # so pickled bench models resolve
+
+
+def parse_shape(text):
+    return tuple(int(part) for part in text.replace("x", ",").split(",") if part.strip())
+
+
+def load_shapes(pt_path, explicit):
+    if explicit:
+        return [parse_shape(s) for s in explicit]
+
+    meta_path = pt_path.replace(".pt", ".meta.json")
+    if os.path.exists(meta_path):
+        with open(meta_path) as fh:
+            return [tuple(json.load(fh)["input_shape"])]
+
+    raise SystemExit(
+        f"no input shape given and no sidecar at {meta_path}; pass --input-shape 1,3,224,224"
+    )
+
+
+def convert(pt_path, pte_path, shapes, verbose=True):
+    model = torch.load(pt_path, weights_only=False)
+    model.eval()
+
+    example = tuple(torch.randn(*shape) for shape in shapes)
+
+    t0 = time.perf_counter()
+    exported = torch.export.export(model, example)
+    t_export = time.perf_counter() - t0
+
+    t0 = time.perf_counter()
+    program = to_edge(exported).to_executorch()
+    t_lower = time.perf_counter() - t0
+
+    with open(pte_path, "wb") as fh:
+        program.write_to_file(fh)
+
+    size_kb = os.path.getsize(pte_path) / 1024.0
+    if verbose:
+        print(
+            f"{os.path.basename(pt_path)} -> {os.path.basename(pte_path)}  "
+            f"({size_kb:,.1f} KiB, export {t_export:.2f}s, lower {t_lower:.2f}s)"
+        )
+    return pte_path
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("checkpoint", nargs="+", help="one or more .pt files")
+    ap.add_argument("-o", "--output", help="output .pte path (single input only)")
+    ap.add_argument(
+        "--input-shape",
+        action="append",
+        help="example input shape, e.g. 1,3,224,224. Repeat for multi-input models. "
+             "Defaults to the shape in the .meta.json sidecar.",
+    )
+    args = ap.parse_args()
+
+    if args.output and len(args.checkpoint) > 1:
+        raise SystemExit("-o only makes sense with a single checkpoint")
+
+    for pt_path in args.checkpoint:
+        pte_path = args.output or pt_path.replace(".pt", ".pte")
+        convert(pt_path, pte_path, load_shapes(pt_path, args.input_shape))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/bench/results/baseline.json b/bench/results/baseline.json
new file mode 100644
index 0000000..c8a9cf1
--- /dev/null
+++ b/bench/results/baseline.json
@@ -0,0 +1,537 @@
+{
+  "label": "baseline",
+  "ruby": "3.3.6",
+  "models": {
+    "add_mul": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        3
+      ],
+      "output_shape": [
+        1,
+        3
+      ],
+      "params": 0,
+      "eager_p50_ms": 0.0145,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 0.0,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.02076880000458914,
+          "p90_ms": 0.02408510000577735,
+          "min_ms": 0.01926800000546791,
+          "mean_ms": 0.021781460000966032,
+          "allocs_per_call": 1.1,
+          "batch": 10,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.02636199999667749,
+          "p90_ms": 0.031727000002016816,
+          "min_ms": 0.02446344444706483,
+          "mean_ms": 0.027857608889058205,
+          "allocs_per_call": 13.0,
+          "batch": 9,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.01911862500492134,
+          "p90_ms": 0.026002749990539087,
+          "min_ms": 0.01811824999720102,
+          "mean_ms": 0.020677174999264025,
+          "allocs_per_call": 3.0,
+          "batch": 8,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.006522160001622979,
+          "p90_ms": 0.009024400001180766,
+          "min_ms": 0.006193720000737812,
+          "mean_ms": 0.007270512000104645,
+          "allocs_per_call": 1.0,
+          "batch": 25,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.01233957142890826,
+          "p90_ms": 0.016678428583613174,
+          "min_ms": 0.012170571429643522,
+          "mean_ms": 0.013376588570801169,
+          "allocs_per_call": 6.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.06959199998846088,
+          "p90_ms": 0.09470724998550395,
+          "min_ms": 0.0642697499984024,
+          "mean_ms": 0.07619806999514367,
+          "allocs_per_call": 10.0,
+          "batch": 4,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 72.5
+    },
+    "mlp_1024x4": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        1024
+      ],
+      "output_shape": [
+        1,
+        1024
+      ],
+      "params": 4198400,
+      "eager_p50_ms": 0.3041,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.1920928955078125e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.652993000016977,
+          "p90_ms": 0.7002090000014505,
+          "min_ms": 0.6268390000059298,
+          "mean_ms": 0.6580987199959054,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.9236140000439264,
+          "p90_ms": 1.0335790000226552,
+          "min_ms": 0.8889450000424404,
+          "mean_ms": 0.9757094000042343,
+          "allocs_per_call": 1034.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 48.63811699999587,
+          "p90_ms": 53.011588999993364,
+          "min_ms": 44.01434200008225,
+          "mean_ms": 48.45398396001201,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 1.1307360000500921,
+          "p90_ms": 1.1827119999452407,
+          "min_ms": 1.0720290000563182,
+          "mean_ms": 1.134630680016926,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 1.1739120000129333,
+          "p90_ms": 1.2208489999920857,
+          "min_ms": 1.1140029999978651,
+          "mean_ms": 1.172578240002622,
+          "allocs_per_call": 7.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 58.81534600007399,
+          "p90_ms": 69.10078999999314,
+          "min_ms": 51.90361200004645,
+          "mean_ms": 59.92618367999512,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 17.3
+    },
+    "mlp_512x2": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        512
+      ],
+      "output_shape": [
+        1,
+        512
+      ],
+      "params": 525312,
+      "eager_p50_ms": 0.0553,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 4.172325134277344e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.34645499999896856,
+          "p90_ms": 0.3912410000452837,
+          "min_ms": 0.32401049998043163,
+          "mean_ms": 0.3620703000001413,
+          "allocs_per_call": 1.0,
+          "batch": 2,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.49753500002225337,
+          "p90_ms": 0.5484034999767573,
+          "min_ms": 0.45937499999126885,
+          "mean_ms": 0.5244627600018248,
+          "allocs_per_call": 522.0,
+          "batch": 2,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 3.2381769999574317,
+          "p90_ms": 3.56931099997837,
+          "min_ms": 3.032615000051919,
+          "mean_ms": 3.300494080003773,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.5557749999525186,
+          "p90_ms": 0.5889049999723284,
+          "min_ms": 0.5291100000022197,
+          "mean_ms": 0.560937239984014,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.5679810000174257,
+          "p90_ms": 0.6180100000392486,
+          "min_ms": 0.5304489999389261,
+          "mean_ms": 0.5747456800054351,
+          "allocs_per_call": 7.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 4.224286999942706,
+          "p90_ms": 4.950387999997474,
+          "min_ms": 4.020548999960738,
+          "mean_ms": 4.363867159986512,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 23.3
+    },
+    "mnist_cnn": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        1,
+        28,
+        28
+      ],
+      "output_shape": [
+        1,
+        10
+      ],
+      "params": 20490,
+      "eager_p50_ms": 0.2853,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 2.1979212760925293e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.5717129999993631,
+          "p90_ms": 0.9584560000348574,
+          "min_ms": 0.49598900000091817,
+          "mean_ms": 0.6628527199973178,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.7665200000701589,
+          "p90_ms": 0.9408979999534495,
+          "min_ms": 0.7177969999929701,
+          "mean_ms": 0.8202253999888853,
+          "allocs_per_call": 910.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 4.907056999968518,
+          "p90_ms": 5.1328480000165655,
+          "min_ms": 4.7372840000434735,
+          "mean_ms": 4.980831200005014,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.015250117645765011,
+          "p90_ms": 0.01774576470752971,
+          "min_ms": 0.013802764710014933,
+          "mean_ms": 0.015397437646777904,
+          "allocs_per_call": 1.0,
+          "batch": 17,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.02176472726618654,
+          "p90_ms": 0.03172154544534517,
+          "min_ms": 0.019480454542727704,
+          "mean_ms": 0.02458076727180014,
+          "allocs_per_call": 7.0,
+          "batch": 11,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 5.492608000054133,
+          "p90_ms": 5.707145000087621,
+          "min_ms": 5.386334999911924,
+          "mean_ms": 5.60199628000646,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 10.7
+    },
+    "mobilenet_v2": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 3504872,
+      "eager_p50_ms": 16.7216,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 3.552713678800501e-15,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 92.12486700005229,
+          "p90_ms": 96.08018500000526,
+          "min_ms": 91.18256399995062,
+          "mean_ms": 93.3415714000148,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 134.17037099998197,
+          "p90_ms": 140.56829300000118,
+          "min_ms": 132.25384099996518,
+          "mean_ms": 135.04748839130056,
+          "allocs_per_call": 153238.0,
+          "batch": 1,
+          "samples": 23
+        },
+        "forward": {
+          "p50_ms": 1583.833129000027,
+          "p90_ms": 1595.9298100000296,
+          "min_ms": 1553.9235009999857,
+          "mean_ms": 1576.1671424000042,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "to_a_flat": {
+          "p50_ms": 1.1048710000522988,
+          "p90_ms": 1.5665079999962472,
+          "min_ms": 1.0373669999808044,
+          "mean_ms": 1.1858775600239824,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 1.120189999937793,
+          "p90_ms": 1.7299060000368627,
+          "min_ms": 1.0436879999815574,
+          "mean_ms": 1.2455656800011639,
+          "allocs_per_call": 7.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 1680.1996759999156,
+          "p90_ms": 1706.5600399999994,
+          "min_ms": 1643.74602099997,
+          "mean_ms": 1676.490115999968,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 5
+        }
+      },
+      "binding_overhead_pct": 5.7
+    },
+    "resnet18": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 11689512,
+      "eager_p50_ms": 25.2618,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 3.0994415283203125e-06,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 92.2036309999612,
+          "p90_ms": 93.57744599992657,
+          "min_ms": 91.10361099999409,
+          "mean_ms": 93.15590187999533,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 135.21731299999828,
+          "p90_ms": 145.03970199996274,
+          "min_ms": 132.3683150000079,
+          "mean_ms": 137.5184453636135,
+          "allocs_per_call": 153238.0,
+          "batch": 1,
+          "samples": 22
+        },
+        "forward": {
+          "p50_ms": 8260.745396999937,
+          "p90_ms": 8312.04729000001,
+          "min_ms": 8185.855024000034,
+          "mean_ms": 8250.059020999994,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "to_a_flat": {
+          "p50_ms": 1.0774900000569687,
+          "p90_ms": 1.4932889999954568,
+          "min_ms": 1.0376640000231419,
+          "mean_ms": 1.1572682399946643,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 1.0859120000077382,
+          "p90_ms": 1.111513999944691,
+          "min_ms": 1.0420880000765465,
+          "mean_ms": 1.0853960800113782,
+          "allocs_per_call": 7.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 9312.70320300007,
+          "p90_ms": 9411.727165999991,
+          "min_ms": 8422.749630999988,
+          "mean_ms": 9150.658892000001,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 5
+        }
+      },
+      "binding_overhead_pct": 11.3
+    },
+    "tiny_mlp": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        8
+      ],
+      "output_shape": [
+        1,
+        8
+      ],
+      "params": 72,
+      "eager_p50_ms": 0.0103,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 5.960464477539063e-08,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.02456460000151613,
+          "p90_ms": 0.032935800004452176,
+          "min_ms": 0.02241140000478481,
+          "mean_ms": 0.02702123466830623,
+          "allocs_per_call": 1.0,
+          "batch": 15,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.03305133333242338,
+          "p90_ms": 0.04895583333563991,
+          "min_ms": 0.029222833328882796,
+          "mean_ms": 0.0353861266671629,
+          "allocs_per_call": 18.0,
+          "batch": 6,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.01984440000342147,
+          "p90_ms": 0.026944499995806837,
+          "min_ms": 0.018113999999513908,
+          "mean_ms": 0.02129326000022047,
+          "allocs_per_call": 3.0,
+          "batch": 10,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.01269243750101623,
+          "p90_ms": 0.017476812502081884,
+          "min_ms": 0.011496687498890878,
+          "mean_ms": 0.013733722499296164,
+          "allocs_per_call": 1.0,
+          "batch": 16,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.019814099999848622,
+          "p90_ms": 0.02536895000275763,
+          "min_ms": 0.017912399999886475,
+          "mean_ms": 0.020795947999658893,
+          "allocs_per_call": 7.0,
+          "batch": 20,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.08190175000777344,
+          "p90_ms": 0.11005799998997645,
+          "min_ms": 0.07286874998158055,
+          "mean_ms": 0.08943054000269512,
+          "allocs_per_call": 11.0,
+          "batch": 4,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 75.8
+    }
+  }
+}
\ No newline at end of file
diff --git a/bench/results/optimized.json b/bench/results/optimized.json
new file mode 100644
index 0000000..80720ac
--- /dev/null
+++ b/bench/results/optimized.json
@@ -0,0 +1,726 @@
+{
+  "label": "optimized",
+  "ruby": "3.3.6",
+  "models": {
+    "add_mul": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        3
+      ],
+      "output_shape": [
+        1,
+        3
+      ],
+      "params": 0,
+      "eager_p50_ms": 0.0145,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 0.0,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.014998714293921824,
+          "p90_ms": 0.018761857144714407,
+          "min_ms": 0.013659000014091103,
+          "mean_ms": 0.015813451429624235,
+          "allocs_per_call": 1.1,
+          "batch": 14,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.01873742855553116,
+          "p90_ms": 0.024843428588740477,
+          "min_ms": 0.016694285704943468,
+          "mean_ms": 0.019687965715482796,
+          "allocs_per_call": 8.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.014352099992720468,
+          "p90_ms": 0.01760489999469428,
+          "min_ms": 0.01279550001527241,
+          "mean_ms": 0.01469683999857807,
+          "allocs_per_call": 3.0,
+          "batch": 10,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.0033251346149672126,
+          "p90_ms": 0.0040800000008927705,
+          "min_ms": 0.003056423076066914,
+          "mean_ms": 0.003482246923060582,
+          "allocs_per_call": 1.0,
+          "batch": 52,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.009346666653679373,
+          "p90_ms": 0.01570283332815355,
+          "min_ms": 0.00926416665455084,
+          "mean_ms": 0.010442433332779427,
+          "allocs_per_call": 6.0,
+          "batch": 6,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.049813750024441106,
+          "p90_ms": 0.06045899999662652,
+          "min_ms": 0.0450327499947889,
+          "mean_ms": 0.05156988000180718,
+          "allocs_per_call": 10.0,
+          "batch": 4,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.013856833334102703,
+          "p90_ms": 0.021622666660429484,
+          "min_ms": 0.013650666687681223,
+          "mean_ms": 0.015318819999568705,
+          "allocs_per_call": 1.0,
+          "batch": 6,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.002973526306959684,
+          "p90_ms": 0.003488684210663594,
+          "min_ms": 0.002927052623578531,
+          "mean_ms": 0.00324178947171037,
+          "allocs_per_call": 1.0,
+          "batch": 19,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.043596857137475,
+          "p90_ms": 0.047947857150835,
+          "min_ms": 0.03869799999327889,
+          "mean_ms": 0.0443971199976139,
+          "allocs_per_call": 6.0,
+          "batch": 7,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 71.2
+    },
+    "mlp_1024x4": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        1024
+      ],
+      "output_shape": [
+        1,
+        1024
+      ],
+      "params": 4198400,
+      "eager_p50_ms": 0.3041,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.1920928955078125e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.06250849997968544,
+          "p90_ms": 0.07271750001791588,
+          "min_ms": 0.05847224997523881,
+          "mean_ms": 0.06447142999604694,
+          "allocs_per_call": 1.0,
+          "batch": 4,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.1160860000103033,
+          "p90_ms": 0.13837666665494908,
+          "min_ms": 0.09969966663447849,
+          "mean_ms": 0.11900458666180688,
+          "allocs_per_call": 9.0,
+          "batch": 3,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 54.12094099983733,
+          "p90_ms": 61.87080099994091,
+          "min_ms": 47.39836899989314,
+          "mean_ms": 54.941272959986236,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.027626571441682506,
+          "p90_ms": 0.03473657141382448,
+          "min_ms": 0.02497514284576547,
+          "mean_ms": 0.02886607428471117,
+          "allocs_per_call": 1.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.03750544442482351,
+          "p90_ms": 0.04727288887806935,
+          "min_ms": 0.03258833334661581,
+          "mean_ms": 0.03863444889045947,
+          "allocs_per_call": 7.0,
+          "batch": 9,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 55.495825999969384,
+          "p90_ms": 63.84405400012838,
+          "min_ms": 48.77920199987784,
+          "mean_ms": 58.402606400004515,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.018339555557152682,
+          "p90_ms": 0.024278555555510038,
+          "min_ms": 0.017246444435335836,
+          "mean_ms": 0.01991288889156648,
+          "allocs_per_call": 1.0,
+          "batch": 9,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.004082322580108022,
+          "p90_ms": 0.006502483866795721,
+          "min_ms": 0.0035809677478203907,
+          "mean_ms": 0.004759859354723425,
+          "allocs_per_call": 1.0,
+          "batch": 31,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 50.83168999999543,
+          "p90_ms": 55.88996300002691,
+          "min_ms": 47.017570999969394,
+          "mean_ms": 51.29670439997426,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 2.5
+    },
+    "mlp_512x2": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        512
+      ],
+      "output_shape": [
+        1,
+        512
+      ],
+      "params": 525312,
+      "eager_p50_ms": 0.0553,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 4.172325134277344e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.03937714284672568,
+          "p90_ms": 0.04495342857678354,
+          "min_ms": 0.0366071428743453,
+          "mean_ms": 0.04011966285621124,
+          "allocs_per_call": 1.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.06423614286177326,
+          "p90_ms": 0.0729142857055974,
+          "min_ms": 0.05849514283389518,
+          "mean_ms": 0.0650556285719566,
+          "allocs_per_call": 9.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 2.9522489999180834,
+          "p90_ms": 3.1591609999850334,
+          "min_ms": 2.860650999991776,
+          "mean_ms": 2.9849600799934706,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.015329533334806909,
+          "p90_ms": 0.017312599993601907,
+          "min_ms": 0.013659066659480839,
+          "mean_ms": 0.015374389332767654,
+          "allocs_per_call": 1.0,
+          "batch": 15,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.020216857137711486,
+          "p90_ms": 0.025300857130007768,
+          "min_ms": 0.019654571425624972,
+          "mean_ms": 0.021341628570163657,
+          "allocs_per_call": 7.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 2.9839349999747355,
+          "p90_ms": 3.0682090000482276,
+          "min_ms": 2.8799500000786793,
+          "mean_ms": 2.9947944800005644,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.015968416657112055,
+          "p90_ms": 0.020186916666868154,
+          "min_ms": 0.01537033333913011,
+          "mean_ms": 0.016834393335708835,
+          "allocs_per_call": 1.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0034663658580695216,
+          "p90_ms": 0.0043693170726594585,
+          "min_ms": 0.003269146340821086,
+          "mean_ms": 0.0037506058534501523,
+          "allocs_per_call": 1.0,
+          "batch": 41,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 2.952393999976266,
+          "p90_ms": 3.169132000039099,
+          "min_ms": 2.857423000023118,
+          "mean_ms": 2.9984875599711813,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 1.1
+    },
+    "mnist_cnn": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        1,
+        28,
+        28
+      ],
+      "output_shape": [
+        1,
+        10
+      ],
+      "params": 20490,
+      "eager_p50_ms": 0.2853,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 2.1979212760925293e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.05314850000104343,
+          "p90_ms": 0.05605774998684865,
+          "min_ms": 0.048492750011064345,
+          "mean_ms": 0.05249002000027758,
+          "allocs_per_call": 1.0,
+          "batch": 8,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.09498479998910625,
+          "p90_ms": 0.10398619997431524,
+          "min_ms": 0.08625119999123854,
+          "mean_ms": 0.09478956000020844,
+          "allocs_per_call": 11.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 4.837546999851838,
+          "p90_ms": 5.188069000041651,
+          "min_ms": 4.750070000000051,
+          "mean_ms": 4.900682480010801,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.0033396470638870275,
+          "p90_ms": 0.005000999996863196,
+          "min_ms": 0.003249117646512733,
+          "mean_ms": 0.0036871529423746427,
+          "allocs_per_call": 1.0,
+          "batch": 17,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.010015111115535547,
+          "p90_ms": 0.012421611106421752,
+          "min_ms": 0.009720222225142709,
+          "mean_ms": 0.010577944444270947,
+          "allocs_per_call": 7.0,
+          "batch": 18,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 4.846068000006198,
+          "p90_ms": 5.364657999962219,
+          "min_ms": 4.7888880001210055,
+          "mean_ms": 4.953432000002067,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.017596692312228976,
+          "p90_ms": 0.023823153854279484,
+          "min_ms": 0.016504769239243336,
+          "mean_ms": 0.018956489229822182,
+          "allocs_per_call": 1.0,
+          "batch": 13,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0029960999972900026,
+          "p90_ms": 0.004977579997103021,
+          "min_ms": 0.002896799996960908,
+          "mean_ms": 0.003355367199401371,
+          "allocs_per_call": 1.0,
+          "batch": 50,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 4.808935000028214,
+          "p90_ms": 4.971674999978859,
+          "min_ms": 4.758790000096269,
+          "mean_ms": 4.8570765200202,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 0.2
+    },
+    "mobilenet_v2": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 3504872,
+      "eager_p50_ms": 16.7216,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 3.552713678800501e-15,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 7.08477800003493,
+          "p90_ms": 7.336223000038444,
+          "min_ms": 6.893123000054402,
+          "mean_ms": 7.126804159979656,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 13.910722999980862,
+          "p90_ms": 14.592204999871683,
+          "min_ms": 13.115629999902012,
+          "mean_ms": 13.958455439988029,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 1617.6040410000496,
+          "p90_ms": 1657.353214000068,
+          "min_ms": 1585.368826999911,
+          "mean_ms": 1613.680584199983,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "to_a_flat": {
+          "p50_ms": 0.017103222211921495,
+          "p90_ms": 0.022507777783984138,
+          "min_ms": 0.015394111111769842,
+          "mean_ms": 0.01823966222218587,
+          "allocs_per_call": 1.0,
+          "batch": 9,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.025267916669236,
+          "p90_ms": 0.03130666666114242,
+          "min_ms": 0.02212325000527926,
+          "mean_ms": 0.02583475666673015,
+          "allocs_per_call": 7.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 1621.0363160000725,
+          "p90_ms": 1692.7830370000265,
+          "min_ms": 1595.1547699999082,
+          "mean_ms": 1629.8671099999865,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.5138799999713228,
+          "p90_ms": 0.5543059999126854,
+          "min_ms": 0.4771559999880992,
+          "mean_ms": 0.5175402399709128,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.003750380951065121,
+          "p90_ms": 0.004793761902311374,
+          "min_ms": 0.0035721904753570144,
+          "mean_ms": 0.004041249524431935,
+          "allocs_per_call": 1.0,
+          "batch": 21,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 1598.0783929999234,
+          "p90_ms": 1603.2729609999024,
+          "min_ms": 1551.5668419998292,
+          "mean_ms": 1583.1353985999613,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 5
+        }
+      },
+      "binding_overhead_pct": 0.2
+    },
+    "resnet18": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 11689512,
+      "eager_p50_ms": 25.2618,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 3.0994415283203125e-06,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 6.996566999987408,
+          "p90_ms": 7.072008000022834,
+          "min_ms": 6.733713999892643,
+          "mean_ms": 6.967049120021329,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 13.270541000110825,
+          "p90_ms": 13.98027599998386,
+          "min_ms": 12.893027000018265,
+          "mean_ms": 13.471172159997877,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 8262.01535999985,
+          "p90_ms": 8383.147234000035,
+          "min_ms": 8176.512075999881,
+          "mean_ms": 8262.119483999959,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "to_a_flat": {
+          "p50_ms": 0.01711387500336059,
+          "p90_ms": 0.021148749993926685,
+          "min_ms": 0.015305375001162247,
+          "mean_ms": 0.01784622999593921,
+          "allocs_per_call": 1.0,
+          "batch": 8,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.02338469231779947,
+          "p90_ms": 0.0273930769218658,
+          "min_ms": 0.021447076925631754,
+          "mean_ms": 0.024311760001952423,
+          "allocs_per_call": 7.0,
+          "batch": 13,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 8334.781338999846,
+          "p90_ms": 8410.709581999981,
+          "min_ms": 8270.799388999876,
+          "mean_ms": 8346.793081799933,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.5264019998776348,
+          "p90_ms": 0.5785930000001827,
+          "min_ms": 0.48730299999988347,
+          "mean_ms": 0.5270717200073705,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0037259444398942934,
+          "p90_ms": 0.005752222225257558,
+          "min_ms": 0.0035026666738404958,
+          "mean_ms": 0.004316611110274001,
+          "allocs_per_call": 1.0,
+          "batch": 18,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 8211.870632,
+          "p90_ms": 8357.648381000217,
+          "min_ms": 8188.81488299985,
+          "mean_ms": 8248.607941599994,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 5
+        }
+      },
+      "binding_overhead_pct": 0.9
+    },
+    "tiny_mlp": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        8
+      ],
+      "output_shape": [
+        1,
+        8
+      ],
+      "params": 72,
+      "eager_p50_ms": 0.0103,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 5.960464477539063e-08,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.014956222230466665,
+          "p90_ms": 0.01697249999526523,
+          "min_ms": 0.013851333341739923,
+          "mean_ms": 0.01524577111316224,
+          "allocs_per_call": 1.0,
+          "batch": 18,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.018404833326712833,
+          "p90_ms": 0.023572583340107183,
+          "min_ms": 0.017173999992792233,
+          "mean_ms": 0.019280833334960334,
+          "allocs_per_call": 9.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.013018999993619218,
+          "p90_ms": 0.01672150000331385,
+          "min_ms": 0.01275183332912396,
+          "mean_ms": 0.013839993334840983,
+          "allocs_per_call": 3.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.003213489358034728,
+          "p90_ms": 0.0039554893627358435,
+          "min_ms": 0.0031533829769614385,
+          "mean_ms": 0.0034005361697943067,
+          "allocs_per_call": 1.0,
+          "batch": 47,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.010425950006265339,
+          "p90_ms": 0.013030700006311235,
+          "min_ms": 0.009658450005645136,
+          "mean_ms": 0.011029981999399752,
+          "allocs_per_call": 7.0,
+          "batch": 20,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.04981020001650904,
+          "p90_ms": 0.05641439997816633,
+          "min_ms": 0.045513399982155534,
+          "mean_ms": 0.05059866400006286,
+          "allocs_per_call": 11.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.014560800002527685,
+          "p90_ms": 0.016741150000143534,
+          "min_ms": 0.013613049998184579,
+          "mean_ms": 0.01498507999940557,
+          "allocs_per_call": 1.0,
+          "batch": 20,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0030794285738097857,
+          "p90_ms": 0.0037150952363975065,
+          "min_ms": 0.0029015238093658504,
+          "mean_ms": 0.00317731428627407,
+          "allocs_per_call": 1.0,
+          "batch": 42,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.03741899996612119,
+          "p90_ms": 0.05001274996629945,
+          "min_ms": 0.03598749998445783,
+          "mean_ms": 0.04033837999031675,
+          "allocs_per_call": 6.0,
+          "batch": 4,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 73.9
+    }
+  }
+}
\ No newline at end of file
diff --git a/bench/run_bench.rb b/bench/run_bench.rb
new file mode 100644
index 0000000..93fbfc9
--- /dev/null
+++ b/bench/run_bench.rb
@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+# Eval + benchmark harness for executorch-ruby.
+#
+#   bundle exec ruby bench/run_bench.rb --label baseline
+#
+# For every model under bench/models/*.pte it does two things:
+#
+#   1. Eval    -- runs the golden input through the gem and compares against the
+#                 output PyTorch produced for the same checkpoint.
+#   2. Profile -- times each leg of a Ruby inference call separately, so you can
+#                 see where the time actually goes:
+#
+#                   tensor_new_flat    Array(flat) + shape -> Tensor
+#                   tensor_new_nested  nested Array         -> Tensor
+#                   forward            model.predict([t])   (tensor pre-built)
+#                   to_a_flat          Tensor -> flat Array
+#                   to_a_nested        Tensor -> nested Array
+#                   e2e                all of the above, as an app would call it
+#
+# Timings use batched sampling: each sample runs the block enough times to span
+# ~500us, so a per-call cost of a few microseconds isn't swamped by the cost of
+# reading the clock. Allocations per call come from GC.stat, because on this
+# boundary object churn is usually the story.
+
+require "fileutils"
+require "json"
+require "optparse"
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "executorch"
+
+BENCH_DIR = __dir__
+MODELS_DIR = File.join(BENCH_DIR, "models")
+RESULTS_DIR = File.join(BENCH_DIR, "results")
+
+options = {
+  label: "current",
+  models: nil,
+  samples: 25,
+  warmup: 20,
+  sample_us: 500,
+  budget_s: 3.0,
+  tolerance: 1e-4,
+  out: nil
+}
+
+OptionParser.new do |o|
+  o.banner = "Usage: ruby bench/run_bench.rb [options]"
+  o.on("--label LABEL", "name for this run (used in the results filename)") { |v| options[:label] = v }
+  o.on("--models a,b,c", Array, "only these models") { |v| options[:models] = v }
+  o.on("--samples N", Integer, "timing samples per phase") { |v| options[:samples] = v }
+  o.on("--warmup N", Integer, "warmup iterations per phase") { |v| options[:warmup] = v }
+  o.on("--sample-us N", Integer, "target duration of one timing sample") { |v| options[:sample_us] = v }
+  o.on("--budget-s F", Float, "max seconds to spend timing one phase") { |v| options[:budget_s] = v }
+  o.on("--tolerance F", Float, "max abs error allowed vs PyTorch") { |v| options[:tolerance] = v }
+  o.on("--out PATH", "results JSON path") { |v| options[:out] = v }
+  o.on("-h", "--help") { puts o; exit }
+end.parse!
+
+def now
+  Process.clock_gettime(Process::CLOCK_MONOTONIC)
+end
+
+# Time a block, reporting per-call cost. Batches calls per sample so that short
+# operations are measured against a clock that can actually see them, and stops
+# early once `budget_s` is spent so a 2-second resnet18 call doesn't stall the
+# suite waiting for its 25th sample.
+def measure(samples:, warmup:, sample_us:, budget_s:)
+  # One cold call tells us what scale we're working at.
+  t0 = now
+  yield
+  single = [now - t0, 1e-9].max
+
+  [warmup, (budget_s / 4 / single).floor].min.clamp(1, warmup).times { yield }
+
+  batch = ((sample_us / 1e6) / single).ceil.clamp(1, 200_000)
+
+  timings = []
+  deadline = now + budget_s
+  while timings.size < samples
+    t = now
+    batch.times { yield }
+    timings << (now - t) / batch
+    break if timings.size >= 5 && now > deadline
+  end
+
+  GC.start
+  before = GC.stat(:total_allocated_objects)
+  batch.times { yield }
+  allocs = (GC.stat(:total_allocated_objects) - before).to_f / batch
+
+  timings.sort!
+  {
+    "p50_ms" => timings[timings.size / 2] * 1000,
+    "p90_ms" => timings[(timings.size * 0.9).floor] * 1000,
+    "min_ms" => timings.first * 1000,
+    "mean_ms" => (timings.sum / timings.size) * 1000,
+    "allocs_per_call" => allocs.round(1),
+    "batch" => batch,
+    "samples" => timings.size
+  }
+end
+
+# Read the golden input/output pair written by make_pt_models.py.
+def read_golden(meta)
+  path = File.join(MODELS_DIR, "#{meta['name']}.io.bin")
+  floats = File.binread(path).unpack("e*")
+  input = floats[0, meta["input_numel"]]
+  output = floats[meta["input_numel"], meta["output_numel"]]
+  [input, output]
+end
+
+def nest(flat, shape)
+  return flat.dup if shape.size <= 1
+
+  stride = shape[1..].inject(:*)
+  Array.new(shape[0]) { |i| nest(flat[i * stride, stride], shape[1..]) }
+end
+
+def max_abs_error(actual, expected)
+  actual.each_with_index.map { |v, i| (v - expected[i]).abs }.max || 0.0
+end
+
+def fmt(ms)
+  ms >= 1 ? format("%8.3f", ms) : format("%8.4f", ms)
+end
+
+metas = Dir[File.join(MODELS_DIR, "*.meta.json")].sort.map { |p| JSON.parse(File.read(p)) }
+metas.select! { |m| options[:models].include?(m["name"]) } if options[:models]
+metas.select! { |m| File.exist?(File.join(MODELS_DIR, "#{m['name']}.pte")) }
+
+if metas.empty?
+  abort "No .pte models found in #{MODELS_DIR}.\n" \
+        "Run: python3 bench/make_pt_models.py && python3 bench/pt_to_pte.py bench/models/*.pt"
+end
+
+puts "executorch-ruby bench  (label=#{options[:label]}, ruby=#{RUBY_VERSION})"
+puts
+
+results = { "label" => options[:label], "ruby" => RUBY_VERSION, "models" => {} }
+failures = []
+
+metas.each do |meta|
+  name = meta["name"]
+  shape = meta["input_shape"]
+  out_shape = meta["output_shape"]
+  flat_input, expected = read_golden(meta)
+  nested_input = nest(flat_input, shape)
+
+  model = Executorch::Model.new(File.join(MODELS_DIR, "#{name}.pte"))
+
+  # --- eval: do we agree with PyTorch? ---
+  tensor = Executorch::Tensor.new(flat_input, shape: shape)
+  output = model.predict([tensor]).first
+  actual = output.flat_to_a
+  error = max_abs_error(actual, expected)
+  ok = actual.size == expected.size && error <= options[:tolerance]
+  failures << "#{name}: max_abs_error=#{error}" unless ok
+
+  # --- profile: where does an inference call spend its time? ---
+  cfg = {
+    samples: options[:samples],
+    warmup: options[:warmup],
+    sample_us: options[:sample_us],
+    budget_s: options[:budget_s]
+  }
+  phases = {
+    "tensor_new_flat" => measure(**cfg) { Executorch::Tensor.new(flat_input, shape: shape) },
+    "tensor_new_nested" => measure(**cfg) { Executorch::Tensor.new(nested_input) },
+    "forward" => measure(**cfg) { model.predict([tensor]) },
+    "to_a_flat" => measure(**cfg) { output.flat_to_a },
+    "to_a_nested" => measure(**cfg) { output.to_a },
+    "e2e" => measure(**cfg) do
+      t = Executorch::Tensor.new(flat_input, shape: shape)
+      model.predict([t]).first.to_a
+    end
+  }
+
+  # The binary path is opt-in and newer than the rest of the API, so only
+  # measure it when the extension actually has it.
+  if Executorch::Tensor.respond_to?(:from_bytes)
+    packed = flat_input.pack("f*")
+    phases["tensor_from_bytes"] = measure(**cfg) do
+      Executorch::Tensor.from_bytes(packed, shape: shape)
+    end
+    phases["to_binary"] = measure(**cfg) { output.to_binary }
+    phases["e2e_binary"] = measure(**cfg) do
+      t = Executorch::Tensor.from_bytes(packed, shape: shape)
+      model.predict([t]).first.to_binary.unpack("f*")
+    end
+
+    packed_ok = Executorch::Tensor.from_bytes(packed, shape: shape).flat_to_a
+    binary_err = max_abs_error(packed_ok, flat_input)
+    failures << "#{name}: from_bytes round-trip error=#{binary_err}" if binary_err > 0
+  end
+
+  e2e = phases["e2e"]["p50_ms"]
+  fwd = phases["forward"]["p50_ms"]
+  overhead_pct = e2e.positive? ? ((e2e - fwd) / e2e * 100) : 0.0
+
+  results["models"][name] = {
+    "regime" => meta["regime"],
+    "input_shape" => shape,
+    "output_shape" => out_shape,
+    "params" => meta["params"],
+    "eager_p50_ms" => meta["eager_p50_ms"],
+    "eval" => { "passed" => ok, "max_abs_error" => error, "tolerance" => options[:tolerance] },
+    "phases" => phases,
+    "binding_overhead_pct" => overhead_pct.round(1)
+  }
+
+  status = ok ? "PASS" : "FAIL"
+  puts "#{name}  [#{meta['regime']}]  in=#{shape.inspect} out=#{out_shape.inspect} " \
+       "params=#{meta['params']}"
+  puts "  eval: #{status}  max_abs_error=#{format('%.2e', error)}  " \
+       "(pytorch eager p50 #{format('%.3f', meta['eager_p50_ms'])} ms)"
+  puts format("  %-18s %10s %10s %14s", "phase", "p50 ms", "p90 ms", "allocs/call")
+  phases.each do |phase, stats|
+    puts format("  %-18s %10s %10s %14.1f",
+                phase, fmt(stats["p50_ms"]), fmt(stats["p90_ms"]), stats["allocs_per_call"])
+  end
+  puts format("  binding overhead: %.1f%% of e2e is not forward()", overhead_pct)
+  puts
+end
+
+FileUtils.mkdir_p(RESULTS_DIR)
+out_path = options[:out] || File.join(RESULTS_DIR, "#{options[:label]}.json")
+File.write(out_path, JSON.pretty_generate(results))
+puts "results -> #{out_path}"
+
+if failures.empty?
+  puts "all evals passed"
+else
+  puts "EVAL FAILURES:"
+  failures.each { |f| puts "  #{f}" }
+  exit 1
+end
diff --git a/ext/executorch/executorch.cpp b/ext/executorch/executorch.cpp
index f926110..6efd3f1 100644
--- a/ext/executorch/executorch.cpp
+++ b/ext/executorch/executorch.cpp
@@ -13,6 +13,7 @@
 #include <executorch/runtime/core/evalue.h>
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 
+#include <cstring>
 #include <memory>
 #include <vector>
 #include <string>
@@ -41,65 +42,33 @@ class RubyTensor {
   static RubyTensor create(Array data, Array shape, Symbol dtype) {
     HANDLE_ET_ERRORS
 
-    // Convert shape to vector using the proper SizesType
-    std::vector<et::aten::SizesType> sizes;
-    for (size_t i = 0; i < shape.size(); i++) {
-      sizes.push_back(static_cast<et::aten::SizesType>(
-        detail::From_Ruby<int64_t>().convert(shape[i].value())));
-    }
-
-    // Get scalar type from symbol
+    std::vector<et::aten::SizesType> sizes = read_sizes(shape.value());
     et::aten::ScalarType scalar_type = executorch_ruby::symbol_to_scalar_type(dtype.value());
 
-    // Convert data based on dtype and create tensor using templated make_tensor_ptr
-    // The templated version takes ownership of the data vector and handles memory management
-    if (scalar_type == et::aten::ScalarType::Float) {
-      std::vector<float> float_data;
-      float_data.reserve(data.size());
-      for (size_t i = 0; i < data.size(); i++) {
-        float_data.push_back(static_cast<float>(detail::From_Ruby<double>().convert(data[i].value())));
-      }
-      // Use templated make_tensor_ptr which manages data ownership
-      TensorPtr tensor_ptr = make_tensor_ptr<float>(
-        std::move(sizes),
-        std::move(float_data)
-      );
-      return RubyTensor(std::move(tensor_ptr));
-    } else if (scalar_type == et::aten::ScalarType::Double) {
-      std::vector<double> double_data;
-      double_data.reserve(data.size());
-      for (size_t i = 0; i < data.size(); i++) {
-        double_data.push_back(detail::From_Ruby<double>().convert(data[i].value()));
-      }
-      TensorPtr tensor_ptr = make_tensor_ptr<double>(
-        std::move(sizes),
-        std::move(double_data)
-      );
-      return RubyTensor(std::move(tensor_ptr));
-    } else if (scalar_type == et::aten::ScalarType::Long) {
-      std::vector<int64_t> int_data;
-      int_data.reserve(data.size());
-      for (size_t i = 0; i < data.size(); i++) {
-        int_data.push_back(detail::From_Ruby<int64_t>().convert(data[i].value()));
-      }
-      TensorPtr tensor_ptr = make_tensor_ptr<int64_t>(
-        std::move(sizes),
-        std::move(int_data)
-      );
-      return RubyTensor(std::move(tensor_ptr));
-    } else if (scalar_type == et::aten::ScalarType::Int) {
-      std::vector<int32_t> int_data;
-      int_data.reserve(data.size());
-      for (size_t i = 0; i < data.size(); i++) {
-        int_data.push_back(static_cast<int32_t>(detail::From_Ruby<int64_t>().convert(data[i].value())));
-      }
-      TensorPtr tensor_ptr = make_tensor_ptr<int32_t>(
-        std::move(sizes),
-        std::move(int_data)
-      );
-      return RubyTensor(std::move(tensor_ptr));
-    } else {
-      rb_raise(rb_eArgError, "Unsupported dtype. Use :float, :double, :long, or :int");
+    // make_tensor_ptr takes ownership of the data vector, so each branch fills
+    // one and moves it in.
+    VALUE ary = data.value();
+    Check_Type(ary, T_ARRAY);
+
+    switch (scalar_type) {
+      case et::aten::ScalarType::Float:
+        return RubyTensor(make_tensor_ptr<float>(
+          std::move(sizes),
+          executorch_ruby::read_array<float>(ary, executorch_ruby::to_double_fast)));
+      case et::aten::ScalarType::Double:
+        return RubyTensor(make_tensor_ptr<double>(
+          std::move(sizes),
+          executorch_ruby::read_array<double>(ary, executorch_ruby::to_double_fast)));
+      case et::aten::ScalarType::Long:
+        return RubyTensor(make_tensor_ptr<int64_t>(
+          std::move(sizes),
+          executorch_ruby::read_array<int64_t>(ary, executorch_ruby::to_int64_fast)));
+      case et::aten::ScalarType::Int:
+        return RubyTensor(make_tensor_ptr<int32_t>(
+          std::move(sizes),
+          executorch_ruby::read_array<int32_t>(ary, executorch_ruby::to_int64_fast)));
+      default:
+        rb_raise(rb_eArgError, "Unsupported dtype. Use :float, :double, :long, or :int");
     }
 
     // Should never reach here but compiler needs it
@@ -107,6 +76,52 @@ class RubyTensor {
     END_HANDLE_ET_ERRORS
   }
 
+  // Create a tensor by copying raw bytes straight into the backing buffer.
+  //
+  // This is the escape hatch from per-element conversion: Ruby packs the data
+  // once (Array#pack, or bytes read from a file/socket) and the whole tensor
+  // arrives as one memcpy instead of numel boxed-number conversions. Bytes are
+  // native-endian and must match the element width of `dtype` exactly.
+  static RubyTensor from_binary(String data, Array shape, Symbol dtype) {
+    HANDLE_ET_ERRORS
+
+    std::vector<et::aten::SizesType> sizes = read_sizes(shape.value());
+    et::aten::ScalarType scalar_type = executorch_ruby::symbol_to_scalar_type(dtype.value());
+    const size_t item_size = executorch_ruby::element_size(scalar_type);
+
+    int64_t numel = 1;
+    for (auto size : sizes) {
+      numel *= size;
+    }
+
+    VALUE str = data.value();
+    Check_Type(str, T_STRING);
+    const size_t expected = static_cast<size_t>(numel) * item_size;
+    const size_t actual = static_cast<size_t>(RSTRING_LEN(str));
+    if (actual != expected) {
+      rb_raise(rb_eArgError,
+               "Binary data is %zu bytes but shape %lld x %zu bytes requires %zu",
+               actual, static_cast<long long>(numel), item_size, expected);
+    }
+
+    const char* bytes = RSTRING_PTR(str);
+    switch (scalar_type) {
+      case et::aten::ScalarType::Float:
+        return RubyTensor(make_tensor_ptr<float>(std::move(sizes), copy_bytes<float>(bytes, numel)));
+      case et::aten::ScalarType::Double:
+        return RubyTensor(make_tensor_ptr<double>(std::move(sizes), copy_bytes<double>(bytes, numel)));
+      case et::aten::ScalarType::Long:
+        return RubyTensor(make_tensor_ptr<int64_t>(std::move(sizes), copy_bytes<int64_t>(bytes, numel)));
+      case et::aten::ScalarType::Int:
+        return RubyTensor(make_tensor_ptr<int32_t>(std::move(sizes), copy_bytes<int32_t>(bytes, numel)));
+      default:
+        rb_raise(rb_eArgError, "Unsupported dtype. Use :float, :double, :long, or :int");
+    }
+
+    rb_raise(rb_eRuntimeError, "Unexpected code path in Tensor.from_binary");
+    END_HANDLE_ET_ERRORS
+  }
+
   // Create a float tensor (convenience method)
   static RubyTensor from_array(Array data, Array shape) {
     return create(data, shape, Symbol("float"));
@@ -138,34 +153,39 @@ class RubyTensor {
 
   // Convert tensor data to Ruby array (flattened)
   Array to_a() const {
-    Array result;
+    const int64_t n = tensor_ptr_->numel();
     auto scalar_type = tensor_ptr_->scalar_type();
 
-    if (scalar_type == et::aten::ScalarType::Float) {
-      const float* data = tensor_ptr_->const_data_ptr<float>();
-      for (int64_t i = 0; i < tensor_ptr_->numel(); i++) {
-        result.push(data[i]);
-      }
-    } else if (scalar_type == et::aten::ScalarType::Double) {
-      const double* data = tensor_ptr_->const_data_ptr<double>();
-      for (int64_t i = 0; i < tensor_ptr_->numel(); i++) {
-        result.push(data[i]);
-      }
-    } else if (scalar_type == et::aten::ScalarType::Long) {
-      const int64_t* data = tensor_ptr_->const_data_ptr<int64_t>();
-      for (int64_t i = 0; i < tensor_ptr_->numel(); i++) {
-        result.push(data[i]);
-      }
-    } else if (scalar_type == et::aten::ScalarType::Int) {
-      const int32_t* data = tensor_ptr_->const_data_ptr<int32_t>();
-      for (int64_t i = 0; i < tensor_ptr_->numel(); i++) {
-        result.push(static_cast<int64_t>(data[i]));
-      }
-    } else {
-      rb_raise(rb_eRuntimeError, "Unsupported tensor dtype for to_a");
+    switch (scalar_type) {
+      case et::aten::ScalarType::Float:
+        return Array(executorch_ruby::build_array(
+          tensor_ptr_->const_data_ptr<float>(), n,
+          [](float v) { return DBL2NUM(static_cast<double>(v)); }));
+      case et::aten::ScalarType::Double:
+        return Array(executorch_ruby::build_array(
+          tensor_ptr_->const_data_ptr<double>(), n,
+          [](double v) { return DBL2NUM(v); }));
+      case et::aten::ScalarType::Long:
+        return Array(executorch_ruby::build_array(
+          tensor_ptr_->const_data_ptr<int64_t>(), n,
+          [](int64_t v) { return LL2NUM(v); }));
+      case et::aten::ScalarType::Int:
+        return Array(executorch_ruby::build_array(
+          tensor_ptr_->const_data_ptr<int32_t>(), n,
+          [](int32_t v) { return LONG2NUM(static_cast<long>(v)); }));
+      default:
+        rb_raise(rb_eRuntimeError, "Unsupported tensor dtype for to_a");
     }
+  }
 
-    return result;
+  // Copy the tensor's buffer out as a binary String, native-endian.
+  // The mirror of from_binary: unpack it in Ruby, or hand it straight to
+  // whatever wants bytes.
+  String to_binary() const {
+    const size_t nbytes = static_cast<size_t>(tensor_ptr_->numel()) *
+                          executorch_ruby::element_size(tensor_ptr_->scalar_type());
+    return String(rb_str_new(
+      static_cast<const char*>(tensor_ptr_->const_data_ptr()), static_cast<long>(nbytes)));
   }
 
   // Get string representation
@@ -204,6 +224,25 @@ class RubyTensor {
   }
 
 private:
+  static std::vector<et::aten::SizesType> read_sizes(VALUE shape) {
+    Check_Type(shape, T_ARRAY);
+    const long dims = RARRAY_LEN(shape);
+    std::vector<et::aten::SizesType> sizes;
+    sizes.reserve(static_cast<size_t>(dims));
+    for (long i = 0; i < dims; i++) {
+      sizes.push_back(static_cast<et::aten::SizesType>(
+        executorch_ruby::to_int64_fast(RARRAY_AREF(shape, i))));
+    }
+    return sizes;
+  }
+
+  template <typename T>
+  static std::vector<T> copy_bytes(const char* bytes, int64_t numel) {
+    std::vector<T> out(static_cast<size_t>(numel));
+    std::memcpy(out.data(), bytes, static_cast<size_t>(numel) * sizeof(T));
+    return out;
+  }
+
   TensorPtr tensor_ptr_;
 };
 
@@ -382,90 +421,20 @@ class RubyModel {
     if (!module_->is_method_loaded("forward")) {
       auto load_err = module_->load_method("forward");
       if (load_err != executorch::runtime::Error::Ok) {
-        const char* load_error_name = "Unknown";
-        switch (load_err) {
-          case executorch::runtime::Error::Ok: load_error_name = "Ok"; break;
-          case executorch::runtime::Error::Internal: load_error_name = "Internal"; break;
-          case executorch::runtime::Error::InvalidState: load_error_name = "InvalidState"; break;
-          case executorch::runtime::Error::InvalidArgument: load_error_name = "InvalidArgument"; break;
-          case executorch::runtime::Error::InvalidType: load_error_name = "InvalidType"; break;
-          case executorch::runtime::Error::NotFound: load_error_name = "NotFound"; break;
-          case executorch::runtime::Error::MemoryAllocationFailed: load_error_name = "MemoryAllocationFailed"; break;
-          case executorch::runtime::Error::AccessFailed: load_error_name = "AccessFailed"; break;
-          case executorch::runtime::Error::NotSupported: load_error_name = "NotSupported"; break;
-          default: load_error_name = "Unknown"; break;
-        }
-        rb_raise(rb_eRuntimeError, "Failed to load forward method: %s (%d)", load_error_name, static_cast<int>(load_err));
+        rb_raise(rb_eRuntimeError, "Failed to load forward method: %s",
+                 executorch_ruby::error_name(load_err));
       }
     }
 
-    // Convert Ruby inputs to EValues
-    // Keep tensors alive during forward execution
-    std::vector<TensorPtr> input_tensors;
-    std::vector<EValue> input_evalues;
-
-    for (size_t i = 0; i < inputs.size(); i++) {
-      Object input = inputs[i];
-
-      // Check if it's a RubyTensor
-      if (input.is_a(rb_cObject)) {
-        try {
-          RubyTensor& tensor = detail::From_Ruby<RubyTensor&>().convert(input.value());
-          // Clone the tensor to ensure we own the data during forward
-          TensorPtr cloned = clone_tensor_ptr(tensor.get());
-          input_tensors.push_back(cloned);
-          input_evalues.push_back(EValue(*cloned));
-        } catch (...) {
-          // Try as RubyEValue
-          try {
-            RubyEValue& evalue = detail::From_Ruby<RubyEValue&>().convert(input.value());
-            input_evalues.push_back(evalue.get());
-          } catch (...) {
-            rb_raise(rb_eTypeError, "Input %zu must be a Tensor or EValue", i);
-          }
-        }
-      }
-    }
+    build_inputs(inputs);
 
-    // Execute forward
-    auto result = module_->forward(input_evalues);
+    auto result = module_->forward(input_evalues_);
     if (!result.ok()) {
-      auto error = result.error();
-      const char* error_name = "Unknown";
-      switch (error) {
-        case executorch::runtime::Error::Ok: error_name = "Ok"; break;
-        case executorch::runtime::Error::Internal: error_name = "Internal"; break;
-        case executorch::runtime::Error::InvalidState: error_name = "InvalidState"; break;
-        case executorch::runtime::Error::InvalidArgument: error_name = "InvalidArgument"; break;
-        case executorch::runtime::Error::InvalidType: error_name = "InvalidType"; break;
-        case executorch::runtime::Error::NotFound: error_name = "NotFound"; break;
-        case executorch::runtime::Error::MemoryAllocationFailed: error_name = "MemoryAllocationFailed"; break;
-        case executorch::runtime::Error::AccessFailed: error_name = "AccessFailed"; break;
-        case executorch::runtime::Error::NotSupported: error_name = "NotSupported"; break;
-        default: error_name = "Unknown"; break;
-      }
-      rb_raise(rb_eRuntimeError, "Forward execution failed: %s (%d)", error_name, static_cast<int>(error));
+      rb_raise(rb_eRuntimeError, "Forward execution failed: %s",
+               executorch_ruby::error_name(result.error()));
     }
-    auto outputs = std::move(result.get());
 
-    // Convert outputs to Ruby array of RubyTensors
-    Array ruby_outputs;
-    for (auto& output : outputs) {
-      if (output.isTensor()) {
-        // Clone the tensor to own the data
-        ruby_outputs.push(RubyTensor::from_tensor(output.toTensor()));
-      } else if (output.isInt()) {
-        ruby_outputs.push(output.toInt());
-      } else if (output.isDouble()) {
-        ruby_outputs.push(output.toDouble());
-      } else if (output.isBool()) {
-        ruby_outputs.push(output.toBool() ? Qtrue : Qfalse);
-      } else {
-        ruby_outputs.push(Qnil);
-      }
-    }
-
-    return ruby_outputs;
+    return wrap_outputs(result.get());
     END_HANDLE_ET_ERRORS
   }
 
@@ -476,50 +445,15 @@ class RubyModel {
       rb_raise(rb_eRuntimeError, "Module not loaded");
     }
 
-    // Convert Ruby inputs to EValues
-    // Keep tensors alive during execution
-    std::vector<TensorPtr> input_tensors;
-    std::vector<EValue> input_evalues;
-    for (size_t i = 0; i < inputs.size(); i++) {
-      Object input = inputs[i];
-
-      try {
-        RubyTensor& tensor = detail::From_Ruby<RubyTensor&>().convert(input.value());
-        // Clone the tensor to ensure we own the data during execution
-        TensorPtr cloned = clone_tensor_ptr(tensor.get());
-        input_tensors.push_back(cloned);
-        input_evalues.push_back(EValue(*cloned));
-      } catch (...) {
-        try {
-          RubyEValue& evalue = detail::From_Ruby<RubyEValue&>().convert(input.value());
-          input_evalues.push_back(evalue.get());
-        } catch (...) {
-          rb_raise(rb_eTypeError, "Input %zu must be a Tensor or EValue", i);
-        }
-      }
-    }
+    build_inputs(inputs);
 
-    // Execute method
-    auto result = module_->execute(method_name, input_evalues);
-    auto outputs = executorch_ruby::unwrap_result(std::move(result));
-
-    // Convert outputs to Ruby
-    Array ruby_outputs;
-    for (auto& output : outputs) {
-      if (output.isTensor()) {
-        ruby_outputs.push(RubyTensor::from_tensor(output.toTensor()));
-      } else if (output.isInt()) {
-        ruby_outputs.push(output.toInt());
-      } else if (output.isDouble()) {
-        ruby_outputs.push(output.toDouble());
-      } else if (output.isBool()) {
-        ruby_outputs.push(output.toBool() ? Qtrue : Qfalse);
-      } else {
-        ruby_outputs.push(Qnil);
-      }
+    auto result = module_->execute(method_name, input_evalues_);
+    if (!result.ok()) {
+      rb_raise(rb_eRuntimeError, "Execution of '%s' failed: %s", method_name.c_str(),
+               executorch_ruby::error_name(result.error()));
     }
 
-    return ruby_outputs;
+    return wrap_outputs(result.get());
     END_HANDLE_ET_ERRORS
   }
 
@@ -534,8 +468,68 @@ class RubyModel {
   }
 
 private:
+  // Turn the Ruby argument array into the EValue vector the runtime wants.
+  //
+  // Two things worth noting:
+  //
+  // * The input tensors are used in place rather than cloned. The old code
+  //   deep-copied every input on every call to "own the data during forward",
+  //   but the caller's Array holds a live reference to each Tensor for the
+  //   whole call, so the buffer cannot be collected underneath us -- the copy
+  //   bought nothing and cost a full pass over the input.
+  // * Dispatch is by type check, not by catching the exception Rice throws on a
+  //   failed conversion. Throwing and unwinding to identify a type costs more
+  //   than a small model's entire inference.
+  void build_inputs(Array& inputs) {
+    VALUE ary = inputs.value();
+    Check_Type(ary, T_ARRAY);
+    const long n = RARRAY_LEN(ary);
+
+    input_evalues_.clear();
+    input_evalues_.reserve(static_cast<size_t>(n));
+
+    for (long i = 0; i < n; i++) {
+      VALUE item = RARRAY_AREF(ary, i);
+
+      if (Data_Type<RubyTensor>::is_descendant(item)) {
+        RubyTensor* tensor = detail::unwrap<RubyTensor>(
+          item, Data_Type<RubyTensor>::ruby_data_type(), false);
+        input_evalues_.push_back(EValue(tensor->get()));
+      } else if (Data_Type<RubyEValue>::is_descendant(item)) {
+        RubyEValue* evalue = detail::unwrap<RubyEValue>(
+          item, Data_Type<RubyEValue>::ruby_data_type(), false);
+        input_evalues_.push_back(evalue->get());
+      } else {
+        rb_raise(rb_eTypeError, "Input %ld must be a Tensor or EValue", i);
+      }
+    }
+  }
+
+  // Outputs *are* cloned: they point into the method's planned memory arena,
+  // which the next call overwrites.
+  template <typename Outputs_T>
+  Array wrap_outputs(Outputs_T& outputs) {
+    VALUE ruby_outputs = rb_ary_new_capa(static_cast<long>(outputs.size()));
+    for (auto& output : outputs) {
+      if (output.isTensor()) {
+        rb_ary_push(ruby_outputs,
+                    detail::To_Ruby<RubyTensor>().convert(RubyTensor::from_tensor(output.toTensor())));
+      } else if (output.isInt()) {
+        rb_ary_push(ruby_outputs, LL2NUM(output.toInt()));
+      } else if (output.isDouble()) {
+        rb_ary_push(ruby_outputs, DBL2NUM(output.toDouble()));
+      } else if (output.isBool()) {
+        rb_ary_push(ruby_outputs, output.toBool() ? Qtrue : Qfalse);
+      } else {
+        rb_ary_push(ruby_outputs, Qnil);
+      }
+    }
+    return Array(ruby_outputs);
+  }
+
   std::string path_;
   std::unique_ptr<et::extension::Module> module_;
+  std::vector<EValue> input_evalues_;  // reused across calls to avoid churn
 };
 
 /**
@@ -558,6 +552,9 @@ void Init_executorch() {
       Arg("data"), Arg("shape"), Arg("dtype"))
     .define_singleton_function("from_array", &RubyTensor::from_array,
       Arg("data"), Arg("shape"))
+    .define_singleton_function("from_binary", &RubyTensor::from_binary,
+      Arg("data"), Arg("shape"), Arg("dtype"))
+    .define_method("to_binary", &RubyTensor::to_binary)
     .define_method("shape", &RubyTensor::shape)
     .define_method("dim", &RubyTensor::dim)
     .define_method("numel", &RubyTensor::numel)
diff --git a/ext/executorch/utils.h b/ext/executorch/utils.h
index a19a27e..007eecb 100644
--- a/ext/executorch/utils.h
+++ b/ext/executorch/utils.h
@@ -5,6 +5,10 @@
 #include <rice/stl.hpp>
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/result.h>
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+
+#include <cstdint>
+#include <vector>
 
 // Error handling macros - translate C++ exceptions to Ruby exceptions
 #define HANDLE_ET_ERRORS try {
@@ -20,50 +24,41 @@
 
 namespace executorch_ruby {
 
+// Human-readable name for a runtime error code.
+inline const char* error_name(executorch::runtime::Error error) {
+  switch (error) {
+    case executorch::runtime::Error::Ok:
+      return "Ok";
+    case executorch::runtime::Error::Internal:
+      return "Internal error";
+    case executorch::runtime::Error::InvalidState:
+      return "Invalid state";
+    case executorch::runtime::Error::InvalidArgument:
+      return "Invalid argument";
+    case executorch::runtime::Error::InvalidType:
+      return "Invalid type";
+    case executorch::runtime::Error::NotFound:
+      return "Not found";
+    case executorch::runtime::Error::MemoryAllocationFailed:
+      return "Memory allocation failed";
+    case executorch::runtime::Error::AccessFailed:
+      return "Access failed";
+    case executorch::runtime::Error::NotSupported:
+      return "Not supported";
+    case executorch::runtime::Error::DelegateInvalidCompatibility:
+      return "Delegate invalid compatibility";
+    case executorch::runtime::Error::DelegateMemoryAllocationFailed:
+      return "Delegate memory allocation failed";
+    case executorch::runtime::Error::DelegateInvalidHandle:
+      return "Delegate invalid handle";
+    default:
+      return "Unknown error";
+  }
+}
+
 inline void check_error(executorch::runtime::Error error) {
   if (error != executorch::runtime::Error::Ok) {
-    const char* error_name = "Unknown error";
-    switch (error) {
-      case executorch::runtime::Error::Ok:
-        return;
-      case executorch::runtime::Error::Internal:
-        error_name = "Internal error";
-        break;
-      case executorch::runtime::Error::InvalidState:
-        error_name = "Invalid state";
-        break;
-      case executorch::runtime::Error::InvalidArgument:
-        error_name = "Invalid argument";
-        break;
-      case executorch::runtime::Error::InvalidType:
-        error_name = "Invalid type";
-        break;
-      case executorch::runtime::Error::NotFound:
-        error_name = "Not found";
-        break;
-      case executorch::runtime::Error::MemoryAllocationFailed:
-        error_name = "Memory allocation failed";
-        break;
-      case executorch::runtime::Error::AccessFailed:
-        error_name = "Access failed";
-        break;
-      case executorch::runtime::Error::NotSupported:
-        error_name = "Not supported";
-        break;
-      case executorch::runtime::Error::DelegateInvalidCompatibility:
-        error_name = "Delegate invalid compatibility";
-        break;
-      case executorch::runtime::Error::DelegateMemoryAllocationFailed:
-        error_name = "Delegate memory allocation failed";
-        break;
-      case executorch::runtime::Error::DelegateInvalidHandle:
-        error_name = "Delegate invalid handle";
-        break;
-      default:
-        error_name = "Unknown error";
-        break;
-    }
-    rb_raise(rb_eRuntimeError, "ExecuTorch error: %s", error_name);
+    rb_raise(rb_eRuntimeError, "ExecuTorch error: %s", error_name(error));
   }
 }
 
@@ -137,4 +132,87 @@ inline executorch::aten::ScalarType symbol_to_scalar_type(VALUE sym) {
 
 } // namespace executorch_ruby
 
+// ---------------------------------------------------------------------------
+// Fast scalar conversion
+// ---------------------------------------------------------------------------
+//
+// Rice's From_Ruby/To_Ruby route every single conversion through
+// detail::protect(), which wraps the call in rb_protect() -- a VM tag push plus
+// a setjmp. That is the right default for arbitrary Ruby calls, but for reading
+// a Float out of an Array it costs far more than the conversion itself, and we
+// pay it once per tensor element.
+//
+// The helpers below take the inline path for the two types that make up
+// essentially all real tensor data (Float and Fixnum) and fall back to Rice's
+// protected conversion only for the rare cases -- Bignum, Rational, or an
+// object with a coercion method -- where the call really can raise or run Ruby
+// code.
+
+namespace executorch_ruby {
+
+inline double to_double_fast(VALUE v) {
+  if (RB_FLOAT_TYPE_P(v)) {
+    return RFLOAT_VALUE(v);
+  }
+  if (FIXNUM_P(v)) {
+    return static_cast<double>(FIX2LONG(v));
+  }
+  return Rice::detail::protect(rb_num2dbl, v);
+}
+
+inline int64_t to_int64_fast(VALUE v) {
+  if (FIXNUM_P(v)) {
+    return FIX2LONG(v);
+  }
+  if (RB_FLOAT_TYPE_P(v)) {
+    return static_cast<int64_t>(RFLOAT_VALUE(v));
+  }
+  return Rice::detail::protect(rb_num2ll, v);
+}
+
+// Read a Ruby Array of numbers into a freshly built std::vector<T>.
+//
+// RARRAY_AREF is re-read every iteration rather than caching RARRAY_CONST_PTR:
+// the slow-path conversion above can run Ruby code, which could reallocate the
+// array's backing store and leave a cached pointer dangling.
+template <typename T, typename Convert_T>
+std::vector<T> read_array(VALUE ary, Convert_T convert) {
+  const long n = RARRAY_LEN(ary);
+  std::vector<T> out;
+  out.reserve(static_cast<size_t>(n));
+  for (long i = 0; i < n; i++) {
+    out.push_back(static_cast<T>(convert(RARRAY_AREF(ary, i))));
+  }
+  return out;
+}
+
+// Build a Ruby Array from a contiguous C buffer.
+//
+// rb_ary_new_capa sizes the backing store once, and rb_ary_push on an array we
+// just created cannot raise (it is neither frozen nor shared), so there is no
+// need for the protected call Rice::Array::push would make. Doubles that fit
+// become flonums, so the common case allocates nothing per element.
+template <typename T, typename Box_T>
+VALUE build_array(const T* data, int64_t n, Box_T box) {
+  VALUE ary = rb_ary_new_capa(static_cast<long>(n));
+  for (int64_t i = 0; i < n; i++) {
+    rb_ary_push(ary, box(data[i]));
+  }
+  return ary;
+}
+
+// Bytes per element, for the raw-binary tensor path.
+inline size_t element_size(executorch::aten::ScalarType dtype) {
+  switch (dtype) {
+    case executorch::aten::ScalarType::Float:  return sizeof(float);
+    case executorch::aten::ScalarType::Double: return sizeof(double);
+    case executorch::aten::ScalarType::Int:    return sizeof(int32_t);
+    case executorch::aten::ScalarType::Long:   return sizeof(int64_t);
+    default:
+      rb_raise(rb_eArgError, "Binary tensor I/O supports :float, :double, :int, :long");
+  }
+}
+
+} // namespace executorch_ruby
+
 #endif // EXECUTORCH_RUBY_UTILS_H
diff --git a/lib/executorch.rb b/lib/executorch.rb
index c5d5af5..8075803 100644
--- a/lib/executorch.rb
+++ b/lib/executorch.rb
@@ -41,6 +41,25 @@ def new(data, shape: nil, dtype: :float)
         create(flat_data, shape, dtype)
       end
 
+      # Build a tensor from packed binary data, skipping per-element conversion.
+      #
+      # Every other constructor walks the Array and converts each element
+      # individually. This one hands the runtime a buffer to memcpy, which is
+      # dramatically faster once tensors get large -- worth it whenever the data
+      # is already bytes (an image decoded to a string, a file, a socket) or
+      # when you can pack it once and reuse it.
+      #
+      # Data must be native-endian and match the element width of dtype:
+      # :float => "f*", :double => "d*", :int => "l*", :long => "q*".
+      #
+      # @example
+      #   bytes = pixels.pack("f*")
+      #   Executorch::Tensor.from_bytes(bytes, shape: [1, 3, 224, 224])
+      #
+      def from_bytes(data, shape:, dtype: :float)
+        from_binary(data, shape, dtype)
+      end
+
       private
 
       # Infer the shape from a nested array structure
@@ -58,60 +77,50 @@ def infer_shape(data)
           current = current.first
         end
 
-        # Validate that all elements at each level have consistent sizes
-        validate_shape(data, shape, 0)
-
         shape
       end
 
-      # Validate that the array has consistent shape at all levels
-      # @param data [Array] The data to validate
-      # @param expected_shape [Array<Integer>] The expected shape
-      # @param depth [Integer] Current depth in the array
-      # @raise [ArgumentError] If the array is jagged or inconsistent
-      def validate_shape(data, expected_shape, depth)
-        return if depth >= expected_shape.size
-        return if expected_shape[depth] == 0
-
-        unless data.is_a?(Array)
-          raise ArgumentError, "Inconsistent nesting depth at level #{depth}: expected Array, got #{data.class}"
-        end
-
-        unless data.size == expected_shape[depth]
-          raise ArgumentError, "Jagged array at depth #{depth}: expected size #{expected_shape[depth]}, got #{data.size}"
-        end
+      # Flatten a nested array into a 1D array, validating its structure on the
+      # way down.
+      #
+      # @param data [Array] Potentially nested array
+      # @param shape [Array<Integer>] The shape inferred from the first branch
+      # @return [Array] Flat array
+      # @raise [ArgumentError] If the array is jagged or inconsistently nested
+      def flatten_nested(data, shape)
+        return [] if shape.include?(0)
 
-        data.each_with_index do |element, i|
-          if depth + 1 < expected_shape.size
-            # Expect more nesting
-            unless element.is_a?(Array)
-              raise ArgumentError, "Inconsistent nesting at depth #{depth}, index #{i}: expected Array, got #{element.class}"
+        # Walk one whole level at a time rather than recursing per element: at
+        # depth k every node must be an Array of exactly shape[k] entries, and
+        # Array#concat gathers the next level in C. The recursive flat_map this
+        # replaces allocated an intermediate Array for *every leaf*, which on a
+        # 150k-element input meant 150k throwaway objects before a single
+        # number crossed into C++.
+        level = [data]
+        shape.each_with_index do |dim, depth|
+          nxt = []
+          level.each do |node|
+            unless node.is_a?(Array)
+              raise ArgumentError,
+                    "Inconsistent nesting depth at level #{depth}: expected Array, got #{node.class}"
             end
-            validate_shape(element, expected_shape, depth + 1)
-          else
-            # At leaf level, should be numeric
-            if element.is_a?(Array)
-              raise ArgumentError, "Inconsistent nesting at depth #{depth}, index #{i}: unexpected Array at leaf level"
+            unless node.size == dim
+              raise ArgumentError,
+                    "Jagged array at depth #{depth}: expected size #{dim}, got #{node.size}"
             end
+            nxt.concat(node)
           end
+          level = nxt
         end
-      end
 
-      # Flatten a nested array into a 1D array
-      # @param data [Array] Potentially nested array
-      # @param shape [Array<Integer>] The shape (used to handle empty arrays)
-      # @return [Array] Flat array
-      def flatten_nested(data, shape)
-        return [] if shape.include?(0)
-        deep_flatten(data)
-      end
+        # `level` now holds what should be the leaves. If any branch nested
+        # deeper than the shape says, flattening changes the element count.
+        unless level.flatten.size == level.size
+          raise ArgumentError,
+                "Inconsistent nesting: some elements nest deeper than shape #{shape.inspect}"
+        end
 
-      # Recursively flatten an array
-      # @param data [Array, Numeric] The data to flatten
-      # @return [Array] Flat array
-      def deep_flatten(data)
-        return [data] unless data.is_a?(Array)
-        data.flat_map { |element| deep_flatten(element) }
+        level
       end
     end
 

From fa89e0465205cda8d578aae743dbda5c650d5f15 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 5 Aug 2026 05:10:58 +0000
Subject: [PATCH 2/7] feat: link optimized kernels and XNNPACK when available;
 document perf

The benchmark suite surfaced that forward() on resnet18 takes 8.3s against
PyTorch eager's 25ms on the same checkpoint. That gap is not in the
bindings -- it is the portable reference kernels a default ExecuTorch
build links, which have no vectorization or threading.

- extconf.rb: generalize the whole-archive handling that portable_ops_lib
  already had, and apply it to optimized_native_cpu_ops_lib and
  xnnpack_backend when they are present. Self-registering libraries must be
  whole-archived or the linker drops the registering object files and the
  failure surfaces much later as a missing operator or backend at model
  load.
- bench/pt_to_pte.py: --xnnpack lowers supported subgraphs via
  XnnpackPartitioner, which is required at export time for the delegate to
  do anything at runtime.
- test/binary_tensor_test.rb: cover Tensor.from_bytes / #to_binary,
  including dtype round trips and the byte-length mismatch errors.
- Rakefile: bench:prepare / bench:run / bench:compare.
- README: document the binary tensor path and the kernel choice.
- bench/FINDINGS.md: full writeup of both performance stories.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACSJ1DPT6ryZy6gdvnaJ5K
---
 README.md                  |  48 ++++++++
 Rakefile                   |  23 ++++
 bench/FINDINGS.md          | 226 +++++++++++++++++++++++++++++++++++++
 bench/pt_to_pte.py         |  26 ++++-
 ext/executorch/extconf.rb  |  72 ++++++++----
 test/binary_tensor_test.rb |  98 ++++++++++++++++
 6 files changed, 470 insertions(+), 23 deletions(-)
 create mode 100644 bench/FINDINGS.md
 create mode 100644 test/binary_tensor_test.rb

diff --git a/README.md b/README.md
index 5b9050d..3a86151 100644
--- a/README.md
+++ b/README.md
@@ -94,6 +94,23 @@ tensor = Executorch::Tensor.new([1.0, 2.0, 3.0, 4.0], shape: [2, 2])
 
 **Supported dtypes:** `:float` (default), `:double`, `:int`, `:long`
 
+For large tensors, skip per-element conversion entirely and hand over packed
+bytes — the runtime memcpys them straight into the tensor buffer:
+
+```ruby
+# ~13x faster than the Array constructor on a 150k-element input
+tensor = Executorch::Tensor.from_bytes(pixels.pack("f*"), shape: [1, 3, 224, 224])
+
+# and back out
+bytes = tensor.to_binary
+values = bytes.unpack("f*")
+```
+
+This is the right path whenever your data is already bytes (an image decoded to
+a string, a file, a socket) or when you can pack once and reuse. Data must be
+native-endian and match the dtype's element width: `:float` → `"f*"`,
+`:double` → `"d*"`, `:int` → `"l*"`, `:long` → `"q*"`.
+
 ### Models
 
 ```ruby
@@ -131,6 +148,37 @@ with open("model.pte", "wb") as f:
     et_program.write_to_file(f)
 ```
 
+## Performance
+
+The single biggest factor in inference speed is **which kernels your ExecuTorch
+build links** — not the Ruby layer.
+
+A default build uses the portable kernels: reference implementations written for
+correctness and portability, with no vectorization or threading. They work
+everywhere and they are slow. On this repo's benchmarks, resnet18 takes ~8.3 s
+per call on portable kernels.
+
+Two independent ways to fix that:
+
+```bash
+cmake -B cmake-out \
+  -DEXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON \   # faster CPU kernels, works on existing .pte
+  -DEXECUTORCH_BUILD_XNNPACK=ON \             # XNNPACK delegate, needs a re-export
+  ... # other flags as above
+```
+
+`extconf.rb` links whichever of these it finds in your ExecuTorch install. The
+XNNPACK delegate additionally requires the model to have been lowered with
+`XnnpackPartitioner` at export time — see `bench/pt_to_pte.py --xnnpack`.
+
+For the Ruby side: prefer `Tensor.from_bytes` over the Array constructor for
+large inputs, and `Tensor#flat_to_a` over `#to_a` when you don't need the nested
+shape.
+
+See [`bench/`](bench/) for the eval + profiling harness, and
+[`bench/FINDINGS.md`](bench/FINDINGS.md) for a walkthrough of where the time
+actually goes.
+
 ## Troubleshooting
 
 <details>
diff --git a/Rakefile b/Rakefile
index 7cd5c27..855bdc7 100644
--- a/Rakefile
+++ b/Rakefile
@@ -44,6 +44,29 @@ namespace :executorch do
   end
 end
 
+namespace :bench do
+  models_dir = File.expand_path('bench/models', __dir__)
+
+  desc 'Export the .pt benchmark checkpoints and convert them to .pte'
+  task :prepare do
+    sh 'python3', 'bench/make_pt_models.py', '--all'
+    sh "python3 bench/pt_to_pte.py #{models_dir}/*.pt"
+  end
+
+  desc 'Run evals + profiling (LABEL=name to tag the results file)'
+  task run: :compile do
+    sh 'ruby', 'bench/run_bench.rb', '--label', ENV.fetch('LABEL', 'current')
+  end
+
+  desc 'Compare two result files: rake bench:compare BASE=baseline CURRENT=mine'
+  task :compare do
+    base = ENV.fetch('BASE', 'baseline')
+    current = ENV.fetch('CURRENT', 'current')
+    sh 'ruby', 'bench/compare.rb',
+       "bench/results/#{base}.json", "bench/results/#{current}.json"
+  end
+end
+
 desc 'Clean build artifacts'
 task :clean do
   FileUtils.rm_rf('lib/executorch/executorch.bundle')
diff --git a/bench/FINDINGS.md b/bench/FINDINGS.md
new file mode 100644
index 0000000..5016446
--- /dev/null
+++ b/bench/FINDINGS.md
@@ -0,0 +1,226 @@
+# What the benchmarks found
+
+Measured on the machine that produced `bench/results/*.json` (4-core x86_64,
+Ruby 3.3.6, Rice 4.12, ExecuTorch 0.7.0). Absolute numbers are
+machine-specific; the ratios are the durable part.
+
+There are two separate performance stories here, and it's worth keeping them
+apart:
+
+1. **The bindings** — the cost of getting data across the Ruby ↔ C++ boundary.
+   This is what the gem controls, and it was expensive.
+2. **The kernels** — the cost of the math itself. The gem doesn't control this,
+   but it does control which kernels get linked, and the default is the slow
+   one.
+
+---
+
+## Part 1: the bindings
+
+### The finding
+
+Profiling a call by phase showed that on a small model, most of an "inference"
+call wasn't inference:
+
+| model | e2e | of which `forward()` | binding overhead |
+|---|---|---|---|
+| `tiny_mlp` | 0.082 ms | 0.020 ms | **76%** |
+| `mlp_512x2` | 4.22 ms | 3.24 ms | 23% |
+| `resnet18` | 9313 ms | 8261 ms | 11% |
+
+Broken down per element, the boundary cost about **0.6 µs per element in** and
+**1.1 µs per element out**. For a resnet18 input that's 92 ms to build a tensor
+from an Array of 150,528 floats — before any math happens.
+
+For scale: 1.1 µs per element is roughly 3,000 CPU cycles to move one float
+from a C array into a Ruby Array.
+
+### The cause
+
+Rice is a lovely API, but its default conversion path is built for safety, not
+throughput. Every `Array` element access and every scalar conversion goes
+through `Rice::detail::protect()`:
+
+```cpp
+// rice.hpp
+inline VALUE Array::Proxy::value() const {
+  return detail::protect(rb_ary_entry, array_.value(), index_);
+}
+
+static T convert(VALUE value) {
+  return (T)protect(RubyType<T>::fromRuby, value);   // rb_num2dbl
+}
+```
+
+and `protect()` is:
+
+```cpp
+int state = (int)JumpException::RUBY_TAG_NONE;
+rb_protect(trampoline, (VALUE)(&invoker), &state);
+```
+
+`rb_protect` pushes a VM tag and does a `setjmp` — it exists so a Ruby
+exception can't longjmp past C++ destructors. Entirely correct for arbitrary
+Ruby calls. But the original code read tensor data like this:
+
+```cpp
+for (size_t i = 0; i < data.size(); i++) {
+  float_data.push_back(static_cast<float>(
+    detail::From_Ruby<double>().convert(data[i].value())));
+}
+```
+
+That's **two `rb_protect` calls per element** — one for `data[i].value()`, one
+for the numeric conversion — to read a `Float` that's sitting right there in
+the array. On the way out, `result.push(data[i])` cost another one each.
+
+The setjmp was the entire cost. The conversion itself is a pointer dereference.
+
+### The fixes
+
+**1. Inline the common conversions** (`ext/executorch/utils.h`). `Float` and
+`Fixnum` cover essentially all real tensor data and can't raise, so they take a
+direct path; anything else (Bignum, Rational, an object with `to_f`) still goes
+through Rice's protected call, because those genuinely can run Ruby code:
+
+```cpp
+inline double to_double_fast(VALUE v) {
+  if (RB_FLOAT_TYPE_P(v)) return RFLOAT_VALUE(v);
+  if (FIXNUM_P(v))        return static_cast<double>(FIX2LONG(v));
+  return Rice::detail::protect(rb_num2dbl, v);   // rare, and really can raise
+}
+```
+
+Building the output array uses `rb_ary_new_capa` + `rb_ary_push` — sized once,
+and `rb_ary_push` on an array we just created can't raise, so no `protect` is
+needed. Doubles mostly become flonums, so nothing is allocated per element.
+
+**2. Stop deep-copying every input.** `forward()` cloned each input tensor to
+"own the data during forward". But the caller's Array holds a live reference to
+every input for the whole call, so nothing can be collected underneath us — the
+copy bought nothing and cost a full pass over the input. Outputs *are* still
+cloned, and must be: they point into the method's planned memory arena, which
+the next call overwrites.
+
+**3. Dispatch on type, not on exceptions.** Input type detection was:
+
+```cpp
+try   { RubyTensor& t = detail::From_Ruby<RubyTensor&>().convert(...); }
+catch (...) { try { /* RubyEValue */ } catch (...) { rb_raise(...); } }
+```
+
+Throwing a C++ exception to discover a type costs more than a small model's
+entire inference. Replaced with `Data_Type<RubyTensor>::is_descendant(v)`.
+
+**4. Flatten nested input level-by-level in Ruby.** `Tensor.new([[1.0, 2.0]])`
+went through a recursive `flat_map` that allocated an intermediate Array *per
+leaf* — 153,238 objects for a resnet18 input, before a single number reached
+C++. Walking one level at a time with `Array#concat` does the gathering in C.
+Jagged-array detection is preserved (the level walk catches size mismatches
+directly; a final flatten-size check catches uneven nesting depth).
+
+**5. A raw-binary escape hatch.** `Tensor.from_bytes` / `Tensor#to_binary` skip
+per-element conversion entirely and memcpy the buffer. This is the right path
+whenever the data is already bytes — an image decoded to a string, a file, a
+socket — or when you can pack once and reuse.
+
+### The results
+
+`bundle exec ruby bench/compare.rb bench/results/baseline.json bench/results/optimized.json`
+
+| phase | model | before | after | speedup |
+|---|---|---|---|---|
+| `tensor_new_flat` | resnet18 | 92.20 ms | 7.00 ms | **13.2×** |
+| `tensor_new_nested` | resnet18 | 135.22 ms | 13.27 ms | **10.2×** |
+| `tensor_from_bytes` | resnet18 | — | 0.53 ms | **174×** vs baseline |
+| `to_a_flat` | mobilenet_v2 | 1.105 ms | 0.017 ms | **64.6×** |
+| `to_a_nested` | mlp_1024x4 | 1.174 ms | 0.038 ms | **31.3×** |
+| `to_binary` | mobilenet_v2 | — | 0.004 ms | **291×** vs baseline |
+| `forward` | add_mul | 0.019 ms | 0.014 ms | 1.33× |
+
+Allocations per call, resnet18 nested input: **153,238 → 11**.
+
+Binding overhead as a share of an end-to-end call:
+
+| model | before | after |
+|---|---|---|
+| `mnist_cnn` | 10.7% | 0.2% |
+| `mlp_512x2` | 23.3% | 1.1% |
+| `mlp_1024x4` | 17.3% | 2.5% |
+
+All 59 existing tests pass, and every model's output still matches PyTorch to
+within 1e-4 (most to 1e-7).
+
+`tiny_mlp` still shows ~74% overhead, and that's honest: when `forward()` is
+13 µs, the fixed per-call cost of crossing the boundary at all — allocating the
+result Tensor object, wrapping outputs — is the floor. It's just a much lower
+floor than before (0.082 ms → 0.050 ms e2e).
+
+### What's left on the table
+
+- **A zero-copy input view.** `from_bytes` still copies once into a tensor-owned
+  buffer. A tensor that borrows a frozen Ruby String's memory would remove even
+  that, at the cost of a lifetime rule users have to respect.
+- **Reusing output tensors.** Every `forward()` allocates a fresh `Tensor` per
+  output and clones the data. An opt-in "write into this tensor I already have"
+  API would suit a hot inference loop.
+- **`Tensor#to_a` reshaping** still happens in Ruby. It's now a small share of
+  the cost, but for a many-dimensional output it could move into C.
+- **`shape()`** still uses `Rice::Array::push` (one `rb_protect` per dimension).
+  Irrelevant at 4 dimensions, noted for consistency.
+
+---
+
+## Part 2: the kernels
+
+This one dwarfs everything above, and it isn't a binding problem at all.
+
+With the runtime built the way the README describes, `forward()` on resnet18
+takes **8.26 seconds**. PyTorch eager, same checkpoint, same machine: **25 ms**.
+That's ~330× slower, and no amount of binding work touches it.
+
+The reason is that a default ExecuTorch build links `portable_ops_lib` — the
+reference kernel implementations. They're written for correctness and
+portability, not speed: no vectorization, no blocking, no threading. They are
+the right default for a runtime that has to build anywhere, and the wrong choice
+for anything latency-sensitive.
+
+Two things fix this, and they're independent:
+
+- **Optimized CPU kernels** (`EXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON`) — faster
+  implementations of the same ops. Works on existing `.pte` files, no re-export.
+- **The XNNPACK delegate** (`EXECUTORCH_BUILD_XNNPACK=ON`) — hands whole
+  subgraphs to XNNPACK. Requires the `.pte` to have been lowered with
+  `XnnpackPartitioner` at export time, so it needs both a rebuild *and* a
+  re-export.
+
+`bench/pt_to_pte.py --xnnpack` produces the lowered variant, and `extconf.rb`
+now links either backend when it's present in the ExecuTorch install.
+
+### A linker trap worth knowing about
+
+Kernel libraries and backend delegates register themselves from global
+constructors. A plain `-lxnnpack_backend` only pulls in object files that
+resolve some undefined symbol — and a self-registering object resolves nothing,
+so the linker discards it and the registration silently never happens. You
+find out much later, when a model fails to load with a missing-operator or
+missing-backend error.
+
+They have to be whole-archived: `-Wl,--whole-archive` on Linux,
+`-Wl,-force_load` on macOS. The original `extconf.rb` already did this for
+`portable_ops_lib`; it's now generalized so optimized kernels and the XNNPACK
+backend get the same treatment.
+
+---
+
+## Notes for reproducing
+
+The `forward()` numbers here come from a portable-kernel build, so they are
+*not* a fair "ExecuTorch vs PyTorch" comparison — they're a fair "the gem's
+default build vs PyTorch" comparison, which is the number a user actually
+experiences. Rebuild with optimized kernels or XNNPACK and re-run
+`bench/run_bench.rb` to see where a tuned build lands.
+
+The eager PyTorch timings recorded in each `.meta.json` were measured while the
+machine was otherwise busy in some runs; regenerate the models on an idle
+machine if you want to lean on them.
diff --git a/bench/pt_to_pte.py b/bench/pt_to_pte.py
index 713843a..5bc3424 100644
--- a/bench/pt_to_pte.py
+++ b/bench/pt_to_pte.py
@@ -52,7 +52,7 @@ def load_shapes(pt_path, explicit):
     )
 
 
-def convert(pt_path, pte_path, shapes, verbose=True):
+def convert(pt_path, pte_path, shapes, xnnpack=False, verbose=True):
     model = torch.load(pt_path, weights_only=False)
     model.eval()
 
@@ -63,7 +63,18 @@ def convert(pt_path, pte_path, shapes, verbose=True):
     t_export = time.perf_counter() - t0
 
     t0 = time.perf_counter()
-    program = to_edge(exported).to_executorch()
+    if xnnpack:
+        # Hand every subgraph XNNPACK can claim to the XNNPACK delegate; the
+        # rest falls back to portable kernels. The runtime must be built with
+        # EXECUTORCH_BUILD_XNNPACK=ON to load the result.
+        from executorch.backends.xnnpack.partition.xnnpack_partitioner import XnnpackPartitioner
+        from executorch.exir import to_edge_transform_and_lower
+
+        program = to_edge_transform_and_lower(
+            exported, partitioner=[XnnpackPartitioner()]
+        ).to_executorch()
+    else:
+        program = to_edge(exported).to_executorch()
     t_lower = time.perf_counter() - t0
 
     with open(pte_path, "wb") as fh:
@@ -89,14 +100,21 @@ def main():
         help="example input shape, e.g. 1,3,224,224. Repeat for multi-input models. "
              "Defaults to the shape in the .meta.json sidecar.",
     )
+    ap.add_argument(
+        "--xnnpack",
+        action="store_true",
+        help="lower supported subgraphs to the XNNPACK delegate instead of leaving "
+             "everything on portable kernels (writes <name>.xnnpack.pte by default)",
+    )
     args = ap.parse_args()
 
     if args.output and len(args.checkpoint) > 1:
         raise SystemExit("-o only makes sense with a single checkpoint")
 
+    suffix = ".xnnpack.pte" if args.xnnpack else ".pte"
     for pt_path in args.checkpoint:
-        pte_path = args.output or pt_path.replace(".pt", ".pte")
-        convert(pt_path, pte_path, load_shapes(pt_path, args.input_shape))
+        pte_path = args.output or pt_path.replace(".pt", suffix)
+        convert(pt_path, pte_path, load_shapes(pt_path, args.input_shape), xnnpack=args.xnnpack)
 
 
 if __name__ == "__main__":
diff --git a/ext/executorch/extconf.rb b/ext/executorch/extconf.rb
index 1369b01..ecf2e0f 100644
--- a/ext/executorch/extconf.rb
+++ b/ext/executorch/extconf.rb
@@ -150,34 +150,68 @@ def add_prefix_paths(prefix, include_dirs, lib_dirs)
   end
 end
 
-# Check for portable kernels (if available)
-# Use -force_load on macOS to include global constructors that register kernels
-portable_ops_lib = File.join(lib_dir, 'libportable_ops_lib.a')
-if File.exist?(portable_ops_lib)
+# ==============================================================================
+# Self-registering libraries
+# ==============================================================================
+#
+# Operator kernels and backend delegates announce themselves from global
+# constructors at load time. A plain -l only pulls in the object files needed to
+# resolve an undefined symbol, and a self-registering object resolves nothing --
+# so the linker drops it and the registration never happens. The failure shows
+# up much later as "operator not found" or a missing backend when a model loads.
+#
+# These must be whole-archived: -force_load on macOS, --whole-archive on Linux.
+
+def force_load(lib_dir, lib)
+  path = File.join(lib_dir, "lib#{lib}.a")
+  return false unless File.exist?(path)
+
   $LDFLAGS += if RUBY_PLATFORM =~ /darwin/
-                # macOS: -force_load pulls in all symbols including global constructors
-                " -Wl,-force_load,#{portable_ops_lib}"
+                " -Wl,-force_load,#{path}"
               else
-                # Linux: --whole-archive achieves the same effect
-                ' -Wl,--whole-archive -lportable_ops_lib -Wl,--no-whole-archive'
+                " -Wl,--whole-archive -l#{lib} -Wl,--no-whole-archive"
               end
-  puts '  Linking: portable_ops_lib (force_load)'
+  puts "  Linking: #{lib} (whole archive)"
+  true
+end
 
-  # Portable kernels
-  if File.exist?(File.join(lib_dir, 'libportable_kernels.a'))
-    $LDFLAGS += ' -lportable_kernels'
-    puts '  Linking: portable_kernels'
-  end
+def link_if_present(lib_dir, lib, label = nil)
+  return false unless File.exist?(File.join(lib_dir, "lib#{lib}.a"))
+
+  $LDFLAGS += " -l#{lib}"
+  puts "  Linking: #{lib}#{label ? " (#{label})" : ''}"
+  true
 end
 
-# CPU info and pthreadpool (often required)
-%w[cpuinfo pthreadpool].each do |lib|
-  if File.exist?(File.join(lib_dir, "lib#{lib}.a"))
-    $LDFLAGS += " -l#{lib}"
-    puts "  Linking: #{lib}"
+# Portable kernels: the reference implementations. Correct, and slow -- they are
+# written for clarity and portability, not speed. Always available.
+if force_load(lib_dir, 'portable_ops_lib')
+  link_if_present(lib_dir, 'portable_kernels')
+end
+
+# Optimized CPU kernels, if ExecuTorch was built with
+# EXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON. These override portable
+# implementations for the ops they cover and are dramatically faster.
+if force_load(lib_dir, 'optimized_native_cpu_ops_lib')
+  link_if_present(lib_dir, 'optimized_kernels')
+  link_if_present(lib_dir, 'eigen_blas')
+end
+
+# XNNPACK delegate, if ExecuTorch was built with EXECUTORCH_BUILD_XNNPACK=ON.
+# This only does anything for .pte files that were lowered with
+# XnnpackPartitioner at export time -- the backend has to be present at build
+# time and targeted at export time.
+if force_load(lib_dir, 'xnnpack_backend')
+  %w[XNNPACK xnnpack-microkernels-prod microkernels-prod].each do |lib|
+    link_if_present(lib_dir, lib)
   end
 end
 
+# Threadpool and CPU feature detection: needed by the optimized paths above.
+%w[extension_threadpool cpuinfo pthreadpool].each do |lib|
+  link_if_present(lib_dir, lib)
+end
+
 # Extra libraries from environment (consolidated from version B)
 if ENV['EXECUTORCH_EXTRA_LIBS']
   extra_libs = ENV['EXECUTORCH_EXTRA_LIBS'].split(',').map(&:strip).reject(&:empty?)
diff --git a/test/binary_tensor_test.rb b/test/binary_tensor_test.rb
new file mode 100644
index 0000000..a0b7c09
--- /dev/null
+++ b/test/binary_tensor_test.rb
@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Tests for the raw-binary tensor path (Tensor.from_bytes / Tensor#to_binary),
+# which skips per-element conversion and memcpys the buffer instead.
+class BinaryTensorTest < Minitest::Test
+  def test_from_bytes_builds_expected_tensor
+    tensor = Executorch::Tensor.from_bytes([1.0, 2.0, 3.0, 4.0].pack("f*"), shape: [2, 2])
+
+    assert_equal [2, 2], tensor.shape
+    assert_equal :float, tensor.dtype
+    assert_equal [[1.0, 2.0], [3.0, 4.0]], tensor.to_a
+  end
+
+  def test_from_bytes_matches_array_constructor
+    values = Array.new(64) { |i| i * 0.5 }
+
+    from_array = Executorch::Tensor.new(values, shape: [8, 8])
+    from_bytes = Executorch::Tensor.from_bytes(values.pack("f*"), shape: [8, 8])
+
+    assert_equal from_array.flat_to_a, from_bytes.flat_to_a
+    assert_equal from_array.shape, from_bytes.shape
+  end
+
+  def test_to_binary_round_trips
+    values = Array.new(32) { |i| (i - 16) * 1.25 }
+    tensor = Executorch::Tensor.new(values, shape: [4, 8])
+
+    round_tripped = Executorch::Tensor.from_bytes(tensor.to_binary, shape: [4, 8])
+
+    assert_equal values, round_tripped.flat_to_a
+  end
+
+  def test_to_binary_length_matches_element_width
+    tensor = Executorch::Tensor.new([1.0, 2.0, 3.0], shape: [3])
+    assert_equal 3 * 4, tensor.to_binary.bytesize
+  end
+
+  def test_double_dtype_round_trips
+    values = [1.5, -2.25, 3.125]
+    tensor = Executorch::Tensor.from_bytes(values.pack("d*"), shape: [3], dtype: :double)
+
+    assert_equal :double, tensor.dtype
+    assert_equal values, tensor.flat_to_a
+    assert_equal 3 * 8, tensor.to_binary.bytesize
+  end
+
+  def test_long_dtype_round_trips
+    values = [1, -2, 3_000_000_000]
+    tensor = Executorch::Tensor.from_bytes(values.pack("q*"), shape: [3], dtype: :long)
+
+    assert_equal :long, tensor.dtype
+    assert_equal values, tensor.flat_to_a
+  end
+
+  def test_int_dtype_round_trips
+    values = [1, -2, 3]
+    tensor = Executorch::Tensor.from_bytes(values.pack("l*"), shape: [3], dtype: :int)
+
+    assert_equal :int, tensor.dtype
+    assert_equal values, tensor.flat_to_a
+  end
+
+  def test_too_few_bytes_raises
+    assert_raises(ArgumentError) do
+      Executorch::Tensor.from_bytes([1.0, 2.0].pack("f*"), shape: [2, 2])
+    end
+  end
+
+  def test_too_many_bytes_raises
+    assert_raises(ArgumentError) do
+      Executorch::Tensor.from_bytes([1.0, 2.0, 3.0, 4.0, 5.0].pack("f*"), shape: [2, 2])
+    end
+  end
+
+  def test_wrong_element_width_raises
+    # Doubles packed, but read as floats: twice the bytes the shape calls for.
+    assert_raises(ArgumentError) do
+      Executorch::Tensor.from_bytes([1.0, 2.0].pack("d*"), shape: [2], dtype: :float)
+    end
+  end
+
+  def test_binary_tensor_runs_through_a_model
+    skip "Test models not available. See test/support/README.md" unless models_available?
+
+    model = Executorch::Model.new(model_path("simple.pte"))
+    tensor = Executorch::Tensor.from_bytes([1.0, 2.0, 3.0].pack("f*"), shape: [1, 3])
+
+    output = model.predict([tensor]).first
+
+    # simple.pte computes x * 2 + 1
+    assert_equal [3.0, 5.0, 7.0], output.flat_to_a
+    assert_equal [3.0, 5.0, 7.0], output.to_binary.unpack("f*")
+  end
+
+  include TestHelper
+end

From 441a9d211249ba52326917ca1d87f02f5cbf636a Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 5 Aug 2026 05:21:23 +0000
Subject: [PATCH 3/7] bench: measure the kernel/binding cross-product, fix
 ops-lib conflict

Built ExecuTorch with XNNPACK and optimized kernels and measured all four
combinations rather than assuming. Two corrections to the earlier writeup:

- EXECUTORCH_BUILD_KERNELS_OPTIMIZED bought nothing measurable (resnet18
  8204ms vs 8262ms). It covers elementwise and some BLAS-backed ops; these
  models are all convolution, which still falls back to portable. The
  earlier draft implied it would help.
- extconf.rb whole-archived both operator libraries when both were present.
  Each registers the full op set into the same global table, so that aborts
  the runtime at init on duplicate registration. Now picks one --
  optimized_native_cpu_ops_lib when available, portable_ops_lib otherwise --
  with EXECUTORCH_OPS_LIB to override.

The XNNPACK delegate is the real lever: resnet18 forward 8262ms -> 12.56ms
(658x), and 2x faster than PyTorch eager on the same machine.

That in turn is what makes the binding work matter. Measured with the
original bindings on the XNNPACK runtime, 96.6% of a mobilenet_v2 call was
binding overhead -- building the input tensor cost 28x more than running
the model. With both fixes, mobilenet_v2 end-to-end goes 107.9ms -> 5.26ms
using from_bytes, a 20.5x improvement that is invisible on portable
kernels.

- run_bench.rb: --variant flag to benchmark <model>.<variant>.pte
- results/: all five runs checked in as the evidence
- FINDINGS.md: rewritten around the measured cross-product
- README: XNNPACK build guidance with real numbers

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACSJ1DPT6ryZy6gdvnaJ5K
---
 README.md                 |  32 +++++----
 bench/FINDINGS.md         | 141 +++++++++++++++++++++++++++++++-------
 bench/README.md           |   8 +++
 bench/run_bench.rb        |  28 ++++++--
 ext/executorch/extconf.rb |  37 ++++++----
 5 files changed, 189 insertions(+), 57 deletions(-)

diff --git a/README.md b/README.md
index 3a86151..aaeff57 100644
--- a/README.md
+++ b/README.md
@@ -155,29 +155,35 @@ build links** — not the Ruby layer.
 
 A default build uses the portable kernels: reference implementations written for
 correctness and portability, with no vectorization or threading. They work
-everywhere and they are slow. On this repo's benchmarks, resnet18 takes ~8.3 s
-per call on portable kernels.
+everywhere and they are slow — resnet18 takes **8.3 s** per call.
 
-Two independent ways to fix that:
+Build with the XNNPACK delegate instead:
 
 ```bash
 cmake -B cmake-out \
-  -DEXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON \   # faster CPU kernels, works on existing .pte
-  -DEXECUTORCH_BUILD_XNNPACK=ON \             # XNNPACK delegate, needs a re-export
+  -DEXECUTORCH_BUILD_XNNPACK=ON \
   ... # other flags as above
 ```
 
-`extconf.rb` links whichever of these it finds in your ExecuTorch install. The
-XNNPACK delegate additionally requires the model to have been lowered with
-`XnnpackPartitioner` at export time — see `bench/pt_to_pte.py --xnnpack`.
+and export your model through the XNNPACK partitioner (see
+`bench/pt_to_pte.py --xnnpack`). Both halves are required — the backend has to
+be linked at build time *and* targeted at export time.
 
-For the Ruby side: prefer `Tensor.from_bytes` over the Array constructor for
-large inputs, and `Tensor#flat_to_a` over `#to_a` when you don't need the nested
-shape.
+That takes resnet18 from 8.3 s to **12.6 ms** — 658×, and about 2× faster than
+PyTorch eager on the same machine. `extconf.rb` links the backend automatically
+when it finds it in your ExecuTorch install.
+
+On the Ruby side, once the runtime is fast the boundary becomes the bottleneck:
+
+- Prefer `Tensor.from_bytes` over the Array constructor for large inputs. On
+  mobilenet_v2 that's 0.85 ms instead of 7.6 ms, against a 3.4 ms inference.
+- Prefer `Tensor#flat_to_a` over `#to_a` when you don't need the nested shape.
+- Prefer `Tensor.new(flat, shape: ...)` over a nested Array when you have the
+  choice — shape inference has to walk the nesting.
 
 See [`bench/`](bench/) for the eval + profiling harness, and
-[`bench/FINDINGS.md`](bench/FINDINGS.md) for a walkthrough of where the time
-actually goes.
+[`bench/FINDINGS.md`](bench/FINDINGS.md) for the full walkthrough — including
+why fixing the kernels is what makes the binding work matter.
 
 ## Troubleshooting
 
diff --git a/bench/FINDINGS.md b/bench/FINDINGS.md
index 5016446..d845552 100644
--- a/bench/FINDINGS.md
+++ b/bench/FINDINGS.md
@@ -13,6 +13,10 @@ apart:
    but it does control which kernels get linked, and the default is the slow
    one.
 
+Short version: the kernels are worth **658×** and the bindings are worth up to
+**20×**, and you need both — on a fast runtime, 96.6% of a mobilenet_v2 call
+was binding overhead. Part 3 has the cross-product.
+
 ---
 
 ## Part 1: the bindings
@@ -175,52 +179,137 @@ floor than before (0.082 ms → 0.050 ms e2e).
 
 This one dwarfs everything above, and it isn't a binding problem at all.
 
-With the runtime built the way the README describes, `forward()` on resnet18
+With the runtime built the way the README described, `forward()` on resnet18
 takes **8.26 seconds**. PyTorch eager, same checkpoint, same machine: **25 ms**.
 That's ~330× slower, and no amount of binding work touches it.
 
 The reason is that a default ExecuTorch build links `portable_ops_lib` — the
 reference kernel implementations. They're written for correctness and
-portability, not speed: no vectorization, no blocking, no threading. They are
-the right default for a runtime that has to build anywhere, and the wrong choice
-for anything latency-sensitive.
+portability, not speed: no vectorization, no blocking, no threading. They're the
+right default for a runtime that has to build anywhere, and the wrong choice for
+anything latency-sensitive.
+
+Two candidate fixes, and it's worth being precise about what each one bought,
+because they were not equal:
+
+### Optimized CPU kernels — no measurable help
+
+`EXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON` swaps in vectorized implementations and
+works on existing `.pte` files with no re-export, which makes it sound like the
+easy win. Measured (`results/optimized_kernels.json`):
+
+| model | portable | optimized kernels |
+|---|---|---|
+| resnet18 `forward` | 8262 ms | 8204 ms |
+| mobilenet_v2 `forward` | 1618 ms | 1629 ms |
+| mlp_512x2 `forward` | 2.95 ms | 3.26 ms |
+
+Noise. The optimized set covers elementwise and a few BLAS-backed ops; these
+models spend all their time in convolution, which still falls back to the
+portable implementation. Worth knowing before reaching for it as a fix.
 
-Two things fix this, and they're independent:
+### The XNNPACK delegate — 658×
 
-- **Optimized CPU kernels** (`EXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON`) — faster
-  implementations of the same ops. Works on existing `.pte` files, no re-export.
-- **The XNNPACK delegate** (`EXECUTORCH_BUILD_XNNPACK=ON`) — hands whole
-  subgraphs to XNNPACK. Requires the `.pte` to have been lowered with
-  `XnnpackPartitioner` at export time, so it needs both a rebuild *and* a
-  re-export.
+`EXECUTORCH_BUILD_XNNPACK=ON` plus a re-export through `XnnpackPartitioner`
+hands whole subgraphs to XNNPACK. This needs both a rebuild *and* a re-export —
+the backend has to exist at build time and be targeted at export time, and
+missing either half silently leaves you on portable kernels.
 
-`bench/pt_to_pte.py --xnnpack` produces the lowered variant, and `extconf.rb`
-now links either backend when it's present in the ExecuTorch install.
+| model | portable `forward` | XNNPACK `forward` | speedup | PyTorch eager |
+|---|---|---|---|---|
+| resnet18 | 8262 ms | **12.56 ms** | 658× | 25.3 ms |
+| mobilenet_v2 | 1618 ms | **3.39 ms** | 477× | 16.7 ms |
+| mlp_1024x4 | 48.6 ms | **0.27 ms** | 178× | 0.30 ms |
+| mnist_cnn | 4.91 ms | **0.26 ms** | 18.6× | 0.29 ms |
+| mlp_512x2 | 3.24 ms | **0.12 ms** | 26.6× | 0.055 ms |
+
+Delegated ExecuTorch is *faster than PyTorch eager* on both vision models —
+2.0× on resnet18, 4.9× on mobilenet_v2 — which is the whole point of an
+ahead-of-time-compiled edge runtime.
+
+`bench/pt_to_pte.py --xnnpack` produces the lowered variant; `run_bench.rb
+--variant xnnpack` benchmarks it.
 
 ### A linker trap worth knowing about
 
 Kernel libraries and backend delegates register themselves from global
 constructors. A plain `-lxnnpack_backend` only pulls in object files that
 resolve some undefined symbol — and a self-registering object resolves nothing,
-so the linker discards it and the registration silently never happens. You
-find out much later, when a model fails to load with a missing-operator or
+so the linker discards it and the registration silently never happens. You find
+out much later, when a model fails to load with a missing-operator or
 missing-backend error.
 
 They have to be whole-archived: `-Wl,--whole-archive` on Linux,
-`-Wl,-force_load` on macOS. The original `extconf.rb` already did this for
-`portable_ops_lib`; it's now generalized so optimized kernels and the XNNPACK
-backend get the same treatment.
+`-Wl,-force_load` on macOS. `extconf.rb` already did this for
+`portable_ops_lib`; it's now generalized to the optimized set and the XNNPACK
+backend.
+
+One constraint that follows: **exactly one operator library may be
+whole-archived.** Each registers the full op set into the same global table, so
+linking two aborts the runtime at init on duplicate registration. `extconf.rb`
+picks `optimized_native_cpu_ops_lib` when present and `portable_ops_lib`
+otherwise; `EXECUTORCH_OPS_LIB` overrides.
+
+---
+
+## Part 3: why the two halves need each other
+
+Neither piece of work looks impressive alone. Together they're the whole story.
+
+On portable kernels, the binding fixes barely move end-to-end time — `forward()`
+is so slow that nothing else is visible. That's exactly why the original
+bindings could carry a 0.6 µs/element conversion cost without anyone noticing.
+
+So the real test is the cross-product: **original bindings, XNNPACK kernels**
+(`results/baseline_xnnpack.json`). Once the math is fast, the boundary is all
+that's left:
+
+| model | e2e | `forward()` | overhead |
+|---|---|---|---|
+| mobilenet_v2 | 107.9 ms | 3.7 ms | **96.6%** |
+| resnet18 | 116.4 ms | 11.7 ms | **90.0%** |
+| mlp_1024x4 | 2.61 ms | 0.30 ms | 88.4% |
+| mnist_cnn | 1.21 ms | 0.25 ms | 79.6% |
+
+96.6% of a mobilenet_v2 call spent not doing inference. Building the input
+tensor alone (102.9 ms) cost **28× more than running the model** (3.7 ms).
+
+With the optimized bindings on the same XNNPACK runtime:
+
+| model | e2e before | e2e after | with `from_bytes` | best speedup |
+|---|---|---|---|---|
+| mobilenet_v2 | 107.9 ms | 12.97 ms | **5.26 ms** | **20.5×** |
+| resnet18 | 116.4 ms | 19.67 ms | **13.69 ms** | **8.5×** |
+| mlp_1024x4 | 2.61 ms | 0.47 ms | **0.38 ms** | **6.9×** |
+| mnist_cnn | 1.21 ms | 0.47 ms | **0.29 ms** | **4.2×** |
+
+The takeaway: **fix the kernels first, because that's the 658×** — but the
+moment you do, the bindings become the bottleneck, and on mobilenet_v2 they're
+worth another 20×.
+
+It also changes which API matters. On a fast runtime, `Tensor.from_bytes` isn't
+a micro-optimization: for mobilenet_v2 it's the difference between spending
+7.6 ms or 0.85 ms getting the input across, against a 3.4 ms inference.
 
 ---
 
 ## Notes for reproducing
 
-The `forward()` numbers here come from a portable-kernel build, so they are
-*not* a fair "ExecuTorch vs PyTorch" comparison — they're a fair "the gem's
-default build vs PyTorch" comparison, which is the number a user actually
-experiences. Rebuild with optimized kernels or XNNPACK and re-run
-`bench/run_bench.rb` to see where a tuned build lands.
+Four result files, the full cross-product:
+
+| file | bindings | kernels |
+|---|---|---|
+| `baseline.json` | original | portable |
+| `optimized.json` | optimized | portable |
+| `optimized_kernels.json` | optimized | optimized CPU kernels |
+| `baseline_xnnpack.json` | original | XNNPACK |
+| `xnnpack.json` | optimized | XNNPACK |
+
+```bash
+bundle exec ruby bench/compare.rb bench/results/baseline_xnnpack.json bench/results/xnnpack.json
+```
 
-The eager PyTorch timings recorded in each `.meta.json` were measured while the
-machine was otherwise busy in some runs; regenerate the models on an idle
-machine if you want to lean on them.
+The eager PyTorch timings recorded in each `.meta.json` were measured on the
+same machine but not under controlled conditions (some runs overlapped a
+compile). Treat them as an anchor, not a benchmark; regenerate the models on an
+idle machine if you want to lean on them.
diff --git a/bench/README.md b/bench/README.md
index cfcd338..ec755fa 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -42,6 +42,14 @@ bundle exec ruby bench/run_bench.rb --label mine
 bundle exec ruby bench/compare.rb bench/results/baseline.json bench/results/mine.json
 ```
 
+To benchmark an XNNPACK-delegated build (see `FINDINGS.md` -- this is worth
+~658x on `forward`), export the lowered variant and point the harness at it:
+
+```bash
+python3 bench/pt_to_pte.py bench/models/*.pt --xnnpack   # writes <name>.xnnpack.pte
+bundle exec ruby bench/run_bench.rb --label xnnpack --variant xnnpack
+```
+
 `pt_to_pte.py` works on any `.pt` you have, not just these:
 
 ```bash
diff --git a/bench/run_bench.rb b/bench/run_bench.rb
index 93fbfc9..41e5769 100644
--- a/bench/run_bench.rb
+++ b/bench/run_bench.rb
@@ -37,6 +37,7 @@
 options = {
   label: "current",
   models: nil,
+  variant: nil,
   samples: 25,
   warmup: 20,
   sample_us: 500,
@@ -49,6 +50,9 @@
   o.banner = "Usage: ruby bench/run_bench.rb [options]"
   o.on("--label LABEL", "name for this run (used in the results filename)") { |v| options[:label] = v }
   o.on("--models a,b,c", Array, "only these models") { |v| options[:models] = v }
+  o.on("--variant NAME", "use <model>.<NAME>.pte instead of <model>.pte (e.g. xnnpack)") do |v|
+    options[:variant] = v
+  end
   o.on("--samples N", Integer, "timing samples per phase") { |v| options[:samples] = v }
   o.on("--warmup N", Integer, "warmup iterations per phase") { |v| options[:warmup] = v }
   o.on("--sample-us N", Integer, "target duration of one timing sample") { |v| options[:sample_us] = v }
@@ -126,19 +130,31 @@ def fmt(ms)
   ms >= 1 ? format("%8.3f", ms) : format("%8.4f", ms)
 end
 
+def pte_path(name, variant)
+  suffix = variant ? ".#{variant}.pte" : ".pte"
+  File.join(MODELS_DIR, "#{name}#{suffix}")
+end
+
 metas = Dir[File.join(MODELS_DIR, "*.meta.json")].sort.map { |p| JSON.parse(File.read(p)) }
 metas.select! { |m| options[:models].include?(m["name"]) } if options[:models]
-metas.select! { |m| File.exist?(File.join(MODELS_DIR, "#{m['name']}.pte")) }
+metas.select! { |m| File.exist?(pte_path(m["name"], options[:variant])) }
 
 if metas.empty?
-  abort "No .pte models found in #{MODELS_DIR}.\n" \
-        "Run: python3 bench/make_pt_models.py && python3 bench/pt_to_pte.py bench/models/*.pt"
+  abort "No#{options[:variant] ? " #{options[:variant]}" : ''} .pte models found in #{MODELS_DIR}.\n" \
+        "Run: python3 bench/make_pt_models.py && python3 bench/pt_to_pte.py bench/models/*.pt" \
+        "#{options[:variant] ? " --#{options[:variant]}" : ''}"
 end
 
-puts "executorch-ruby bench  (label=#{options[:label]}, ruby=#{RUBY_VERSION})"
+puts "executorch-ruby bench  (label=#{options[:label]}, " \
+     "variant=#{options[:variant] || 'portable'}, ruby=#{RUBY_VERSION})"
 puts
 
-results = { "label" => options[:label], "ruby" => RUBY_VERSION, "models" => {} }
+results = {
+  "label" => options[:label],
+  "variant" => options[:variant] || "portable",
+  "ruby" => RUBY_VERSION,
+  "models" => {}
+}
 failures = []
 
 metas.each do |meta|
@@ -148,7 +164,7 @@ def fmt(ms)
   flat_input, expected = read_golden(meta)
   nested_input = nest(flat_input, shape)
 
-  model = Executorch::Model.new(File.join(MODELS_DIR, "#{name}.pte"))
+  model = Executorch::Model.new(pte_path(name, options[:variant]))
 
   # --- eval: do we agree with PyTorch? ---
   tensor = Executorch::Tensor.new(flat_input, shape: shape)
diff --git a/ext/executorch/extconf.rb b/ext/executorch/extconf.rb
index ecf2e0f..dded842 100644
--- a/ext/executorch/extconf.rb
+++ b/ext/executorch/extconf.rb
@@ -183,18 +183,31 @@ def link_if_present(lib_dir, lib, label = nil)
   true
 end
 
-# Portable kernels: the reference implementations. Correct, and slow -- they are
-# written for clarity and portability, not speed. Always available.
-if force_load(lib_dir, 'portable_ops_lib')
-  link_if_present(lib_dir, 'portable_kernels')
-end
-
-# Optimized CPU kernels, if ExecuTorch was built with
-# EXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON. These override portable
-# implementations for the ops they cover and are dramatically faster.
-if force_load(lib_dir, 'optimized_native_cpu_ops_lib')
-  link_if_present(lib_dir, 'optimized_kernels')
-  link_if_present(lib_dir, 'eigen_blas')
+# Exactly one operator library may be whole-archived. Each one registers the
+# full ATen op set into the same global table, so linking two makes the runtime
+# abort at init on duplicate registration.
+#
+#   optimized_native_cpu_ops_lib  vectorized kernels where they exist, portable
+#                                 fallbacks elsewhere. Built with
+#                                 EXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON.
+#   portable_ops_lib              reference implementations only: correct,
+#                                 portable, and slow. Always available.
+#
+# Prefer the optimized set when the install has it. EXECUTORCH_OPS_LIB
+# overrides the choice.
+ops_lib = ENV['EXECUTORCH_OPS_LIB'] ||
+          %w[optimized_native_cpu_ops_lib portable_ops_lib].find do |lib|
+            File.exist?(File.join(lib_dir, "lib#{lib}.a"))
+          end
+
+if ops_lib && force_load(lib_dir, ops_lib)
+  # Kernel implementations backing the registrations above.
+  %w[optimized_kernels optimized_portable_kernels portable_kernels
+     cpublas eigen_blas].each do |lib|
+    link_if_present(lib_dir, lib)
+  end
+else
+  warn 'Warning: no operator library found; models will fail to load.'
 end
 
 # XNNPACK delegate, if ExecuTorch was built with EXECUTORCH_BUILD_XNNPACK=ON.

From 24110f1a4310cf11b4b368bc7f5f0f62009cf413 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 5 Aug 2026 05:21:51 +0000
Subject: [PATCH 4/7] chore: track all bench result files, drop __pycache__
 from git

FINDINGS.md cites baseline_xnnpack.json, xnnpack.json, and
optimized_kernels.json as its evidence, but .gitignore was allowlisting
only two of the five runs. Keep all of them -- they are small and are the
whole point of the writeup. Also untrack a .pyc that slipped in.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACSJ1DPT6ryZy6gdvnaJ5K
---
 .gitignore                                    |  10 +-
 .../__pycache__/bench_models.cpython-311.pyc  | Bin 6610 -> 0 bytes
 bench/results/baseline_xnnpack.json           | 313 ++++++++
 bench/results/optimized_kernels.json          | 726 +++++++++++++++++
 bench/results/xnnpack.json                    | 727 ++++++++++++++++++
 5 files changed, 1772 insertions(+), 4 deletions(-)
 delete mode 100644 bench/__pycache__/bench_models.cpython-311.pyc
 create mode 100644 bench/results/baseline_xnnpack.json
 create mode 100644 bench/results/optimized_kernels.json
 create mode 100644 bench/results/xnnpack.json

diff --git a/.gitignore b/.gitignore
index 0514744..524d8ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,8 +34,10 @@ test/support/models/*.pte
 # Coverage
 /coverage/
 
-# Benchmark artifacts (regenerate with bench/make_pt_models.py + bench/pt_to_pte.py)
+# Benchmark models (regenerate with bench/make_pt_models.py + bench/pt_to_pte.py).
+# Results are kept in git -- they're the evidence behind bench/FINDINGS.md.
 /bench/models/
-/bench/results/*.json
-!/bench/results/baseline.json
-!/bench/results/optimized.json
+
+# Python
+__pycache__/
+*.pyc
diff --git a/bench/__pycache__/bench_models.cpython-311.pyc b/bench/__pycache__/bench_models.cpython-311.pyc
deleted file mode 100644
index c5e36ac5ff313c66602b539612348fc824a7beb5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6610
zcmcIoU2GKB6~43oUax<#!5EBg(j>69F#&=aNJ>kA5E|Pdm;`W$mhsNmJ7ITbxijm(
z7}csGbwO@JB~nb~s#YH;2rBiV@6BVMs&!?l)<~$4`edmOMo<amso%M?yWaK2C{mI;
zJ7@3Qd*<A8&)+>~{?yPAWoUo>oA}tRXY4=pP-=C>&XZ<^vD-{z!%R~&Us@Sf<i9WD
zANDKE$4)WL|0&Y~y8q)q>E*kA#vb7I+Hg=}1%VZM4pvBFg@F}$4pvxV)d4H|9IS{|
z|0x@;(_+AD&>BbmS`&KBve$xMtF{GWZRoXYThZHwUWXjpj$Wr6+fnZATnG<G$C%dj
zM`gHP^9`~1F7+Qi#s(}+PjgKlHB7@XEYs#WTi5u=6n9cO*C+L4&ap%?wO8aYHlmx!
zR7Mq7xScZ`y)PO)mojXgv9w%T=ja)ktR)<ez=-9f_~pwP^@^UzItd`@X}d2wb@?*i
zGm$cqDV{ZwSJJvoOGP~zpkO){-s;Obz#BC%9p|d4VF)xF3zYOK8acCqN+#aRZA;Qi
zrd8Vp?M%*gc-k1(c}f>L7b+GLz)(#r1*(ZeMm5Yt0;}!ai)XppK3g5vF=Clq<r66@
zUE+`1m<Lsr3w;#y%%sl2FUiW2p*dEPMiwhc0qLHwfRHvubTFW&r?{O}A!{ckbnv8)
z85!L^5{-6)0c%_rDP7e(hOnEo;W&_P2K0z;hfk>KG<Wa{NnEosh6$Qwot-5`y}9=&
zKi<<5<$T1-nVKr5`uMq&ZtGly5Qtq*9Ueh&l;%@b4qMfW;?entVQPjshP~pAG0W2W
zBzqZSQYYTfATOb-X+B|zE4_Rq=Wshitm&qe8!Pgf)y3W<4VJbA2^x5`Q`Us-QA}Ey
zY|bHZ6Gh_fiY`ppN_lT@l$ha33);lHxwOW|RnxFjp23)wVZ$6($y*1LMW>a2aDCaH
zbl~qc(;1wf4f`}@*suBEU;)h!X9&2VW12RQOHUt#m^|U|QDJ2yKW9%KJ27zb2$VC)
zyZHg$!}r5N`I#IfQ{GorSR;C05<XRK)Ta>gq!r*cn?cx_4l<_srtyqb{e!E7vPwMO
zXZL+>z}C~Ft}<!UFy~*rx-VsA^nGwiv2TMf?vuXg!FAtq!=sj%P=z+#=<TPk_`D4S
z?Ph>kw$jvmbN}_+&8yd^3XzT{7-NI+pc_dfOf{n?5^fYeAw3%XSR!#Xr>2WD;Y32S
zl8J<9z)K=Rppig~0EJEo+R(A%0JG(5CGd73@b+3j32t9wwZNl71gdmLvZMCo6@Xt>
zYA=vyqX^}n)<KI1-NSgEREC3)Y0wRyGt8-h{xhq@UzI*+0jZA}bUs&ZGpA%7c)pAK
z0dB7?R?L*fHsUDEfi_F+;}W;f^NeyA8hk)nlx>D3Xl>avX#T!J5)axrxCaTIf-i*a
zGfg+tZ<x9&T;FIi?iX~p!77Yt-K|R`WK2sWY+8x)Sx@ZS@i5(7+;d-v)=rGtuL3-q
zWsf2a*TZw+e?>a}8R=MxbS_6a3z5!8t!=mB^CuQxT58?B+`2m-m<#7|NmW!yjaHLV
z>qQ4v%og!q+puTI>_J&>Lrjp-#T7xk2s(_5X6^A!CN$kt;=5?3oUq7S$V|6<HgRJD
zW;#7LU5IR#jDcD^X77hY6aEAlv}hqfQjk{ZHWcNQL{Lj4?ki#!rfg#CC*Hzjo`S#*
zn&=0Bj7ry<&llXY#x?^HCD=&@ygBepnaC$`mm3L?TCFJur78QRDF>=dIpq4ujFF%)
z5yHF45)mRq15zvhMd!P)<uP{6Uun-XzG{7*U?1(h7MSrnVOrj6>*-Rh%~#=-{iNE<
z#(dK-gKPe|zA9|mn`|@wU&G!K<rT?yJgbTbisw@8ZcwP^m@YbLfOP5x&g%W|yU`*2
zYECyDLruGWQ+MJa=}w}HP=cDCby999txoB}c9n!@CbTlAR_R<ZXrb&_F9X9)0c`46
zD=k~{p+_xSZ{~ip^VUvSOWk1!^2b(Ut)GiqQ;Thj&eFEt<!!xx9(g!+-*{*gw!Xd;
zdp-YF{;fw_+Hd`6@s+}sI2<yP$MropWH;E~#3AcxuSI7hf3I-H$s3dN%Jom?K0)yC
zoY5yp8qzier{0V7Mun@rM1utAu64CwuzQVd1{#&%4sx~4f#+&Oy2{l`QTNFn%v7Bk
zIP;6=Mug6NI2)V~=SE0o0FeRY6VCC$!Rf<8GLK1G<~WDpP@+g_iJeljIPgd1gN(&S
zk`D}?9y*6aS<PhAIR4Aw4{M_y@mzEPqu+&#R=Vf<aZ@!Kz?!mAg`@d3<ze71#vYW%
ztFSk5%PO3*Git%=fKY{1rjJ!a-|xD2!O?><SC!$RiX%GxJxPSMNX>Cvstr*ULiu%r
zf?~`nohPdlRpW{q&Z-(Ez|y=|IR*`mRafaqjz`zSj~90+-El+5VKE0ZL5Ann4XBf6
zEGvCLb0ed=>L6LPz3>$EY-iNaMcn7bBzZ=W;Z_BnmXbx5qt8L0*mnRnjXsY$Iu{xq
z#Tw^M-&E&Y=ij@h6k^>=vF_zqH;taUetPaSb^7O9uD?6?u7^1?|KhxQucZ*{S&H>6
z$9ldF^KnCXd-N#-KxAt8Uo+d$wGdzY*<XB1od=gY4`Q$>kE=FZk&(%hY6hKeo<Ceu
zkZDx96W;dPjIvnr@zRj|*EVDz)#eH{`#d!xuR4qu#1Q}_%xTqebaRt<*j!dYF)02R
zFWLJ5kfFqyKO49)F#p0*Z0B-pXI`O{<>xnkK7aKOQ@@+K*K%iOVP>hRce$yz5b5<I
zW_V-XLb=X*@*-ZK$Bj{x(l|kYZhHWrB4Jqx94`cpuLYvP*VfqAfDT`9FXc0v122pc
z?W*WiR$B@)w^^O{?Sy5NYl_0mmLD*u?DG`gML=N}QQ8c#2{!4!$R-pYt31?^Ah2pL
z)O-*9H7W{B|NEyo1Jxbs^PK4j)aEE{Wl=tE*!V!<)n>ii5-2|5R3;y^OjN?7Kv&0A
zBdv}g4o6Y>a(-Sn#!`+~!6HXMsZ14pHYc){tsjwLTuml(LQPKbWJ*t7L4BFYqTaQ+
ztfJL1EN?rKmO~#p5ayGPhnltUrNaB#P-JqVxY~rQPAwBvJ|YNLQN~V~X-h=`O-u>0
z-9ZX4#TQU~wpMJg&#TPcQ1QS1wEU)WQV2`9;W6ETxgu`30jkMdzcZexOsi3_RnQVA
zvDOLP_J;toY%S&wwyi|=6l#9Y9@TH9)3$9Lz?$<;-dXcw^x3m#U)Fd1>W4QE&Igw2
zyO!&_7PUfs&r*HQa(z!B&|}9y{}-V;c0Iby|6667zve`i5rD$n^Qx{=cBgp7B!zI#
zI*I&OkvG$7W<*nuic@$T!fjJ9o@KxP;Le4G3$q?BLMp{_L7~!(l*;oeeux*z4@ak(
zpN%oZiyBmOp!ATHLp4*96$#D(M~VUboL_wJ&hWzU29AhI6(8h4k`MCujeKanYIgxA
z{=xNx3x&-~cxz)3PLh%AypN7e#W~m+THLaz-uZCh!wn3*jA=J0zvz5RzE&CbvP%0A
z?-1BbNFQKwovXIRt9LFfT-w0ZAaNBgeif?Xi#$il>zmt=jGdctbDp><n$U$xg#|nl
zk~zUnAc?a8Rjd#jk`<25M%C3sHQ%5cK~zC5x&L)2j=XYH5naG!Nko_KbuV=tTJAbj
z5>b&cvhCF`i3$ny+c6f)SR?q%3f>aq2LzeTrmS7W<T`78OI?STyAGFF3%g;2yF@0J
zb|VhHz$7y1tXl_=IJE!3<N-HI-Tki~cy01E3{$F|NSdY~w-L1Gcu)|1F-(BMmH3Fj
zC4hKL&^hS_WoQF=`Xb$jm#O4)Lj&?-l@~Iki%Q3knkPxSk+UaHAxS@b(QQ0&@~va<
z_n%7)ynEtg|ImhwBEWdxy^abJDdiq^3J?)cQPzA7N??r<*u|8F*%)0bti4eETMGpg
zeB!DF`LlBuAJh2L^~uJNf)5F`AU`r^Jf`ud>yxc@3M!#mkbiM5{+Py}u1|KfC^+tG
zL0-&FJ*M%e>yvw;N-q+J64=GIzEWs^`QGRkorSjkmG<3*_TA-&J%#o?_flVME3}<n
zX^$7$<M)g&winvoDWaLhnL~y4Lxnfq`TNB}+xeCD!v*|`Pisw)m~V{%%tqGQSnGRA
Oq2&yIvyF7gQ2&2fH;0t~

diff --git a/bench/results/baseline_xnnpack.json b/bench/results/baseline_xnnpack.json
new file mode 100644
index 0000000..8dfd03c
--- /dev/null
+++ b/bench/results/baseline_xnnpack.json
@@ -0,0 +1,313 @@
+{
+  "label": "baseline_xnnpack",
+  "variant": "xnnpack",
+  "ruby": "3.3.6",
+  "models": {
+    "mlp_1024x4": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        1024
+      ],
+      "output_shape": [
+        1,
+        1024
+      ],
+      "params": 4198400,
+      "eager_p50_ms": 0.3041,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.1920928955078125e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.7400639997285907,
+          "p90_ms": 0.7959969998410088,
+          "min_ms": 0.6907470001351612,
+          "mean_ms": 0.7466892399497738,
+          "allocs_per_call": 2.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 1.0895740001615195,
+          "p90_ms": 1.668882000103622,
+          "min_ms": 0.9797050001907337,
+          "mean_ms": 1.2456105199999001,
+          "allocs_per_call": 1034.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.30280800001492025,
+          "p90_ms": 0.33810000013545505,
+          "min_ms": 0.2860660001715587,
+          "mean_ms": 0.31458004004889517,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 1.2910069999634288,
+          "p90_ms": 1.497045000178332,
+          "min_ms": 1.234981999914453,
+          "mean_ms": 1.3282593600342807,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 1.2778950003848877,
+          "p90_ms": 1.436005999948975,
+          "min_ms": 1.2062280002282932,
+          "mean_ms": 1.35228435998215,
+          "allocs_per_call": 7.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 2.6060899999720277,
+          "p90_ms": 3.7642820002474764,
+          "min_ms": 2.4233409999396827,
+          "mean_ms": 2.8521605199603073,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 88.4
+    },
+    "mnist_cnn": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        1,
+        28,
+        28
+      ],
+      "output_shape": [
+        1,
+        10
+      ],
+      "params": 20490,
+      "eager_p50_ms": 0.2853,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.6763806343078613e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.565916000141442,
+          "p90_ms": 0.6634030000896018,
+          "min_ms": 0.5308790000526642,
+          "mean_ms": 0.5862267999691539,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.8466179997412837,
+          "p90_ms": 1.4248889997361402,
+          "min_ms": 0.795964000189997,
+          "mean_ms": 0.9653274799711653,
+          "allocs_per_call": 910.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.24654299977555638,
+          "p90_ms": 0.5424679998213833,
+          "min_ms": 0.14586899987989455,
+          "mean_ms": 0.31385983995278366,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.017083666648431972,
+          "p90_ms": 0.02420616666161853,
+          "min_ms": 0.014782166658733331,
+          "mean_ms": 0.01777201333576765,
+          "allocs_per_call": 1.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.023453799985873047,
+          "p90_ms": 0.028133799999826202,
+          "min_ms": 0.021048466654368287,
+          "mean_ms": 0.023845488001825288,
+          "allocs_per_call": 7.0,
+          "batch": 15,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 1.2081069999112515,
+          "p90_ms": 1.721653000004153,
+          "min_ms": 0.9299259995714237,
+          "mean_ms": 1.2661151199426968,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 79.6
+    },
+    "mobilenet_v2": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 3504872,
+      "eager_p50_ms": 16.7216,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.908195823574488e-15,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 102.92628799970771,
+          "p90_ms": 104.12020099965957,
+          "min_ms": 101.0263909997775,
+          "mean_ms": 102.84736327997962,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 155.07639599991307,
+          "p90_ms": 162.65494600020247,
+          "min_ms": 147.7427700001499,
+          "mean_ms": 154.82151965004505,
+          "allocs_per_call": 153238.0,
+          "batch": 1,
+          "samples": 20
+        },
+        "forward": {
+          "p50_ms": 3.6992239997744036,
+          "p90_ms": 4.481886999656126,
+          "min_ms": 3.3747630000107165,
+          "mean_ms": 3.8534835599966755,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 1.2186909998490592,
+          "p90_ms": 1.8568610003057984,
+          "min_ms": 1.1550660001375945,
+          "mean_ms": 1.3705990399648726,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 1.1799260000771028,
+          "p90_ms": 1.2256310001248494,
+          "min_ms": 1.1466690002635005,
+          "mean_ms": 1.1827635199915676,
+          "allocs_per_call": 7.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 107.85625099970275,
+          "p90_ms": 112.27993300008166,
+          "min_ms": 105.67670999989787,
+          "mean_ms": 108.7121110800399,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 96.6
+    },
+    "resnet18": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 11689512,
+      "eager_p50_ms": 25.2618,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 2.86102294921875e-06,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 99.9813489997905,
+          "p90_ms": 105.08671500019773,
+          "min_ms": 99.19698800013066,
+          "mean_ms": 100.89307547994395,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 149.61627299999236,
+          "p90_ms": 174.2489419998492,
+          "min_ms": 145.3836919999958,
+          "mean_ms": 153.66678860002594,
+          "allocs_per_call": 153238.0,
+          "batch": 1,
+          "samples": 20
+        },
+        "forward": {
+          "p50_ms": 11.678044000291266,
+          "p90_ms": 15.32524200001717,
+          "min_ms": 10.959431000173936,
+          "mean_ms": 12.176673680060048,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 1.1900309996235592,
+          "p90_ms": 1.5651819999220606,
+          "min_ms": 1.143753000178549,
+          "mean_ms": 1.2804550800319703,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 1.2105079999855661,
+          "p90_ms": 1.3113589998283715,
+          "min_ms": 1.1589879995881347,
+          "mean_ms": 1.2478648799515213,
+          "allocs_per_call": 7.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 116.37814999994589,
+          "p90_ms": 120.36179699998684,
+          "min_ms": 113.4326129999863,
+          "mean_ms": 116.81147939993025,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 90.0
+    }
+  }
+}
\ No newline at end of file
diff --git a/bench/results/optimized_kernels.json b/bench/results/optimized_kernels.json
new file mode 100644
index 0000000..412786f
--- /dev/null
+++ b/bench/results/optimized_kernels.json
@@ -0,0 +1,726 @@
+{
+  "label": "optimized_kernels",
+  "ruby": "3.3.6",
+  "models": {
+    "add_mul": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        3
+      ],
+      "output_shape": [
+        1,
+        3
+      ],
+      "params": 0,
+      "eager_p50_ms": 0.0145,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 0.0,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.014464461540998085,
+          "p90_ms": 0.01858507691674906,
+          "min_ms": 0.013939615393190672,
+          "mean_ms": 0.015415252307950423,
+          "allocs_per_call": 1.1,
+          "batch": 13,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.01660378572004057,
+          "p90_ms": 0.019677285714741238,
+          "min_ms": 0.016247642861344502,
+          "mean_ms": 0.017912240001740947,
+          "allocs_per_call": 8.0,
+          "batch": 14,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.012542222217840996,
+          "p90_ms": 0.018580222205047094,
+          "min_ms": 0.012113666672222382,
+          "mean_ms": 0.014054542224483966,
+          "allocs_per_call": 3.0,
+          "batch": 9,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.0029197999992902623,
+          "p90_ms": 0.0034679999998843414,
+          "min_ms": 0.002848319995791826,
+          "mean_ms": 0.003056595199268486,
+          "allocs_per_call": 1.0,
+          "batch": 50,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.008773599984124303,
+          "p90_ms": 0.008998200019050273,
+          "min_ms": 0.008674399987285142,
+          "mean_ms": 0.009104735994696966,
+          "allocs_per_call": 6.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.044796000020141946,
+          "p90_ms": 0.060779400018873275,
+          "min_ms": 0.04289319999770669,
+          "mean_ms": 0.04854343999795674,
+          "allocs_per_call": 10.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.014225799986888887,
+          "p90_ms": 0.01530879999336321,
+          "min_ms": 0.013983200005895924,
+          "mean_ms": 0.015437775993632387,
+          "allocs_per_call": 1.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.002745199996449325,
+          "p90_ms": 0.0033100666617732104,
+          "min_ms": 0.002666000000317581,
+          "mean_ms": 0.0028962399998514834,
+          "allocs_per_call": 1.0,
+          "batch": 15,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.03517149999273291,
+          "p90_ms": 0.042233000006793496,
+          "min_ms": 0.03430733333213235,
+          "mean_ms": 0.037179246667922904,
+          "allocs_per_call": 6.0,
+          "batch": 6,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 72.0
+    },
+    "mlp_1024x4": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        1024
+      ],
+      "output_shape": [
+        1,
+        1024
+      ],
+      "params": 4198400,
+      "eager_p50_ms": 0.3041,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.1920928955078125e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.06148400002530252,
+          "p90_ms": 0.07573360003334528,
+          "min_ms": 0.05853699999534001,
+          "mean_ms": 0.06582528800390718,
+          "allocs_per_call": 1.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.11233380000703619,
+          "p90_ms": 0.12029459999212122,
+          "min_ms": 0.1008598000225902,
+          "mean_ms": 0.11236694399485714,
+          "allocs_per_call": 9.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 50.296554999931686,
+          "p90_ms": 52.673738999828856,
+          "min_ms": 47.53115800008345,
+          "mean_ms": 50.31006151995825,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.025259571430069627,
+          "p90_ms": 0.028966000010249054,
+          "min_ms": 0.024485000007449083,
+          "mean_ms": 0.026269085709437996,
+          "allocs_per_call": 1.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.03426409090355843,
+          "p90_ms": 0.03924381818168595,
+          "min_ms": 0.031216181820458253,
+          "mean_ms": 0.03470148727336147,
+          "allocs_per_call": 7.0,
+          "batch": 11,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 50.473067999973864,
+          "p90_ms": 52.10818199998357,
+          "min_ms": 47.25632999998197,
+          "mean_ms": 50.29405220004264,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.01837699999539057,
+          "p90_ms": 0.02419742856675709,
+          "min_ms": 0.017481571408747447,
+          "mean_ms": 0.019715119997272268,
+          "allocs_per_call": 1.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0033863043525976222,
+          "p90_ms": 0.003878695659533031,
+          "min_ms": 0.0032243478234823156,
+          "mean_ms": 0.003488099129516859,
+          "allocs_per_call": 1.0,
+          "batch": 23,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 51.905406000059884,
+          "p90_ms": 54.97386699994422,
+          "min_ms": 47.942002000127104,
+          "mean_ms": 52.09164168000825,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 0.3
+    },
+    "mlp_512x2": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        512
+      ],
+      "output_shape": [
+        1,
+        512
+      ],
+      "params": 525312,
+      "eager_p50_ms": 0.0553,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 4.172325134277344e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.04006500000741653,
+          "p90_ms": 0.04634716666866249,
+          "min_ms": 0.036776000001736975,
+          "mean_ms": 0.041458659996654504,
+          "allocs_per_call": 1.0,
+          "batch": 6,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.06599800000609927,
+          "p90_ms": 0.07772433332320361,
+          "min_ms": 0.06037349999132857,
+          "mean_ms": 0.06717119999999947,
+          "allocs_per_call": 9.0,
+          "batch": 6,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 3.263455000023896,
+          "p90_ms": 3.3779739999317826,
+          "min_ms": 3.1254139998964092,
+          "mean_ms": 3.2765980399926775,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.015774866672776017,
+          "p90_ms": 0.01841353334081456,
+          "min_ms": 0.013478466659459324,
+          "mean_ms": 0.016395125333171258,
+          "allocs_per_call": 1.0,
+          "batch": 15,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.02092155556157296,
+          "p90_ms": 0.02818833334256649,
+          "min_ms": 0.019657222209288092,
+          "mean_ms": 0.023115826665566098,
+          "allocs_per_call": 7.0,
+          "batch": 9,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 3.3424319999539875,
+          "p90_ms": 3.517221000038262,
+          "min_ms": 3.159382999911031,
+          "mean_ms": 3.3803102399815543,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.01621499999211145,
+          "p90_ms": 0.018707857147351854,
+          "min_ms": 0.015714499990541038,
+          "mean_ms": 0.017050762854913564,
+          "allocs_per_call": 1.0,
+          "batch": 14,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.003330395350340675,
+          "p90_ms": 0.004259976739651689,
+          "min_ms": 0.002989209300468183,
+          "mean_ms": 0.0035801944186671392,
+          "allocs_per_call": 1.0,
+          "batch": 43,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 3.2477140000537474,
+          "p90_ms": 3.3939900001769274,
+          "min_ms": 3.1264550000287272,
+          "mean_ms": 3.2691624000290176,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 2.4
+    },
+    "mnist_cnn": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        1,
+        28,
+        28
+      ],
+      "output_shape": [
+        1,
+        10
+      ],
+      "params": 20490,
+      "eager_p50_ms": 0.2853,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 2.1979212760925293e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.05177187500748914,
+          "p90_ms": 0.0565931250093854,
+          "min_ms": 0.04686387498509248,
+          "mean_ms": 0.051926490000369085,
+          "allocs_per_call": 1.0,
+          "batch": 8,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.0929627999994409,
+          "p90_ms": 0.09907020003083744,
+          "min_ms": 0.08655460001136817,
+          "mean_ms": 0.09294130400121503,
+          "allocs_per_call": 11.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 4.782472999977472,
+          "p90_ms": 5.188642999883086,
+          "min_ms": 4.721529999869745,
+          "mean_ms": 4.905180999967342,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.003064666661548135,
+          "p90_ms": 0.0032643703670382144,
+          "min_ms": 0.0030242222237575334,
+          "mean_ms": 0.003164410369478261,
+          "allocs_per_call": 1.0,
+          "batch": 27,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.009395190480583031,
+          "p90_ms": 0.011266047619886064,
+          "min_ms": 0.009275666668275204,
+          "mean_ms": 0.00990676190581109,
+          "allocs_per_call": 7.0,
+          "batch": 21,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 5.0125199998092285,
+          "p90_ms": 5.453388999967501,
+          "min_ms": 4.835968999941542,
+          "mean_ms": 5.111806920003801,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.0179669999887175,
+          "p90_ms": 0.021191153861694217,
+          "min_ms": 0.016878076918986223,
+          "mean_ms": 0.018799036926373868,
+          "allocs_per_call": 1.0,
+          "batch": 13,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0027709999968512995,
+          "p90_ms": 0.0035274736810127875,
+          "min_ms": 0.0027147105260825664,
+          "mean_ms": 0.0029810389481242866,
+          "allocs_per_call": 1.0,
+          "batch": 38,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 4.818752999881326,
+          "p90_ms": 4.941470999938247,
+          "min_ms": 4.738819999829502,
+          "mean_ms": 4.838987520024602,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 4.6
+    },
+    "mobilenet_v2": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 3504872,
+      "eager_p50_ms": 16.7216,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 3.552713678800501e-15,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 6.7361399999299465,
+          "p90_ms": 6.953532000125051,
+          "min_ms": 6.588782999870091,
+          "mean_ms": 6.811325759963438,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 13.294122000161224,
+          "p90_ms": 13.772924000022613,
+          "min_ms": 12.399716000118133,
+          "mean_ms": 13.172314560015366,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 1628.9095049999105,
+          "p90_ms": 1648.2578529999046,
+          "min_ms": 1609.3089070000133,
+          "mean_ms": 1629.5910469999399,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "to_a_flat": {
+          "p50_ms": 0.01789139998891187,
+          "p90_ms": 0.021627999990414537,
+          "min_ms": 0.01684490000570804,
+          "mean_ms": 0.018871323999519518,
+          "allocs_per_call": 1.0,
+          "batch": 10,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.025561615390100857,
+          "p90_ms": 0.036035846156105084,
+          "min_ms": 0.022701615377557643,
+          "mean_ms": 0.02696574461249559,
+          "allocs_per_call": 7.0,
+          "batch": 13,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 1643.1652859998849,
+          "p90_ms": 1707.8960159999497,
+          "min_ms": 1631.8558689999918,
+          "mean_ms": 1658.6243335999825,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.5046459998538921,
+          "p90_ms": 0.5520350000551844,
+          "min_ms": 0.474335000035353,
+          "mean_ms": 0.5071556399616384,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.003507812508019015,
+          "p90_ms": 0.006766124997170664,
+          "min_ms": 0.003248749990802935,
+          "mean_ms": 0.00457669000070382,
+          "allocs_per_call": 1.0,
+          "batch": 16,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 1711.3766309998937,
+          "p90_ms": 1727.249115999939,
+          "min_ms": 1685.7148410001628,
+          "mean_ms": 1710.2778601999944,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 5
+        }
+      },
+      "binding_overhead_pct": 0.9
+    },
+    "resnet18": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 11689512,
+      "eager_p50_ms": 25.2618,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 3.0994415283203125e-06,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 6.883772000037425,
+          "p90_ms": 7.090614000162532,
+          "min_ms": 6.3925360000212095,
+          "mean_ms": 6.871026799990432,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 13.987237999799618,
+          "p90_ms": 15.0778120000723,
+          "min_ms": 13.020518000075754,
+          "mean_ms": 13.949405959974683,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 8203.788705000079,
+          "p90_ms": 8426.058052999906,
+          "min_ms": 8148.12591000009,
+          "mean_ms": 8250.522004999993,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "to_a_flat": {
+          "p50_ms": 0.018474857142791734,
+          "p90_ms": 0.020431571426472925,
+          "min_ms": 0.017082285726896122,
+          "mean_ms": 0.018627348571109387,
+          "allocs_per_call": 1.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.024915545468088978,
+          "p90_ms": 0.02821981818421839,
+          "min_ms": 0.02300190908499644,
+          "mean_ms": 0.025686945455163368,
+          "allocs_per_call": 7.0,
+          "batch": 11,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 8379.820216000098,
+          "p90_ms": 8430.146924999917,
+          "min_ms": 8188.398285999938,
+          "mean_ms": 8322.726348600008,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 5
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.5340510001587973,
+          "p90_ms": 0.5744139998569153,
+          "min_ms": 0.4938779998155951,
+          "mean_ms": 0.5358813199745782,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0036179090701890263,
+          "p90_ms": 0.004667000005362999,
+          "min_ms": 0.0033434545333544848,
+          "mean_ms": 0.003963890907140343,
+          "allocs_per_call": 1.0,
+          "batch": 11,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 8367.49500399992,
+          "p90_ms": 8406.022297999698,
+          "min_ms": 8224.161960999936,
+          "mean_ms": 8343.375905799894,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 5
+        }
+      },
+      "binding_overhead_pct": 2.1
+    },
+    "tiny_mlp": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        8
+      ],
+      "output_shape": [
+        1,
+        8
+      ],
+      "params": 72,
+      "eager_p50_ms": 0.0103,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 5.960464477539063e-08,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.015271600000232864,
+          "p90_ms": 0.017142299998340604,
+          "min_ms": 0.014068800010136329,
+          "mean_ms": 0.015587852002681757,
+          "allocs_per_call": 1.0,
+          "batch": 20,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.017701999987756217,
+          "p90_ms": 0.020485785723524583,
+          "min_ms": 0.017192714267366682,
+          "mean_ms": 0.018462488564442277,
+          "allocs_per_call": 9.0,
+          "batch": 14,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.013071090920262082,
+          "p90_ms": 0.01728727271587228,
+          "min_ms": 0.012869909079943847,
+          "mean_ms": 0.014085385449685751,
+          "allocs_per_call": 3.0,
+          "batch": 11,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.0031403793118129374,
+          "p90_ms": 0.003806413791733513,
+          "min_ms": 0.002891137933931594,
+          "mean_ms": 0.003282239310684762,
+          "allocs_per_call": 1.0,
+          "batch": 58,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.009645499991014125,
+          "p90_ms": 0.01164570833604254,
+          "min_ms": 0.009106458340587173,
+          "mean_ms": 0.01025448333393797,
+          "allocs_per_call": 7.0,
+          "batch": 24,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.046518799990735715,
+          "p90_ms": 0.055776799945306266,
+          "min_ms": 0.04534660001809243,
+          "mean_ms": 0.04871588801324833,
+          "allocs_per_call": 11.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.014391599984264758,
+          "p90_ms": 0.016003049995561014,
+          "min_ms": 0.013959050011180807,
+          "mean_ms": 0.01486856400151737,
+          "allocs_per_call": 1.0,
+          "batch": 20,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0027809791731669975,
+          "p90_ms": 0.003363770834615328,
+          "min_ms": 0.00273606250781692,
+          "mean_ms": 0.0028756683335965745,
+          "allocs_per_call": 1.0,
+          "batch": 48,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.036591166690413957,
+          "p90_ms": 0.04517349998423015,
+          "min_ms": 0.03579816666388069,
+          "mean_ms": 0.03869243333307774,
+          "allocs_per_call": 6.0,
+          "batch": 6,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 71.9
+    }
+  }
+}
\ No newline at end of file
diff --git a/bench/results/xnnpack.json b/bench/results/xnnpack.json
new file mode 100644
index 0000000..3d1a633
--- /dev/null
+++ b/bench/results/xnnpack.json
@@ -0,0 +1,727 @@
+{
+  "label": "xnnpack",
+  "variant": "xnnpack",
+  "ruby": "3.3.6",
+  "models": {
+    "add_mul": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        3
+      ],
+      "output_shape": [
+        1,
+        3
+      ],
+      "params": 0,
+      "eager_p50_ms": 0.0145,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 0.0,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.016149090945625423,
+          "p90_ms": 0.020622636343019123,
+          "min_ms": 0.014652272718442624,
+          "mean_ms": 0.017125985452201512,
+          "allocs_per_call": 1.1,
+          "batch": 11,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.017573363617305982,
+          "p90_ms": 0.021135727282936306,
+          "min_ms": 0.016754090913970933,
+          "mean_ms": 0.018526359999668784,
+          "allocs_per_call": 8.0,
+          "batch": 11,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.014122200082056224,
+          "p90_ms": 0.017785599993658252,
+          "min_ms": 0.013635399955091998,
+          "mean_ms": 0.014905288007867057,
+          "allocs_per_call": 3.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.002979634146180526,
+          "p90_ms": 0.004421560977168222,
+          "min_ms": 0.0028355365895727227,
+          "mean_ms": 0.003396544391473914,
+          "allocs_per_call": 1.0,
+          "batch": 41,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.008913399960874813,
+          "p90_ms": 0.010602200018183794,
+          "min_ms": 0.008743399939703522,
+          "mean_ms": 0.009374999994179234,
+          "allocs_per_call": 6.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.0502855000377167,
+          "p90_ms": 0.06372325003667356,
+          "min_ms": 0.04803349997928308,
+          "mean_ms": 0.05371912999635242,
+          "allocs_per_call": 10.0,
+          "batch": 4,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.014820800060988404,
+          "p90_ms": 0.02248780001536943,
+          "min_ms": 0.014196999927662546,
+          "mean_ms": 0.016873471988219535,
+          "allocs_per_call": 1.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.002752142855959911,
+          "p90_ms": 0.0051860714458078815,
+          "min_ms": 0.002714785718386078,
+          "mean_ms": 0.0034553942870323745,
+          "allocs_per_call": 1.0,
+          "batch": 14,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.03966175006553385,
+          "p90_ms": 0.06269549999160517,
+          "min_ms": 0.038131499991322926,
+          "mean_ms": 0.0465677600050185,
+          "allocs_per_call": 6.0,
+          "batch": 4,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 71.9
+    },
+    "mlp_1024x4": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        1024
+      ],
+      "output_shape": [
+        1,
+        1024
+      ],
+      "params": 4198400,
+      "eager_p50_ms": 0.3041,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.1920928955078125e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.07002700003795326,
+          "p90_ms": 0.09231459998773062,
+          "min_ms": 0.06407199998648139,
+          "mean_ms": 0.0752179760056606,
+          "allocs_per_call": 1.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.13622333335661096,
+          "p90_ms": 0.19436399998085108,
+          "min_ms": 0.10652433320501586,
+          "mean_ms": 0.15335393332861713,
+          "allocs_per_call": 9.0,
+          "batch": 3,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.2739030001066567,
+          "p90_ms": 0.33252599996558274,
+          "min_ms": 0.24508599972250522,
+          "mean_ms": 0.29149043999495916,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.038049299973863526,
+          "p90_ms": 0.05017569997107785,
+          "min_ms": 0.028547500005515758,
+          "mean_ms": 0.03937305199542607,
+          "allocs_per_call": 1.0,
+          "batch": 10,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.04680922221369757,
+          "p90_ms": 0.057956777760005525,
+          "min_ms": 0.034644000000601714,
+          "mean_ms": 0.04661681332436274,
+          "allocs_per_call": 7.0,
+          "batch": 9,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.4747769999084994,
+          "p90_ms": 0.5598839998128824,
+          "min_ms": 0.3912079996553075,
+          "mean_ms": 0.4813629999080149,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.026624299971444998,
+          "p90_ms": 0.03290750000815024,
+          "min_ms": 0.01851150000220514,
+          "mean_ms": 0.027075044004959636,
+          "allocs_per_call": 1.0,
+          "batch": 10,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.005718400007026503,
+          "p90_ms": 0.006963499981793575,
+          "min_ms": 0.003382400018381304,
+          "mean_ms": 0.005543836001379533,
+          "allocs_per_call": 1.0,
+          "batch": 10,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.37920300019322895,
+          "p90_ms": 0.4678700001932157,
+          "min_ms": 0.3113009997832705,
+          "mean_ms": 0.37990164004440885,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 42.3
+    },
+    "mlp_512x2": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        512
+      ],
+      "output_shape": [
+        1,
+        512
+      ],
+      "params": 525312,
+      "eager_p50_ms": 0.0553,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 2.980232238769531e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.05718385714966904,
+          "p90_ms": 0.07422785711241886,
+          "min_ms": 0.039221428583654676,
+          "mean_ms": 0.055460182863628554,
+          "allocs_per_call": 1.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.08723499990992423,
+          "p90_ms": 0.13134849996276898,
+          "min_ms": 0.06348450006044004,
+          "mean_ms": 0.09356185997603461,
+          "allocs_per_call": 9.0,
+          "batch": 2,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.12169050000920834,
+          "p90_ms": 0.2219614998466568,
+          "min_ms": 0.096158999895124,
+          "mean_ms": 0.13920954001150676,
+          "allocs_per_call": 3.0,
+          "batch": 2,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.016308600000532653,
+          "p90_ms": 0.021818400000483962,
+          "min_ms": 0.0149961333287744,
+          "mean_ms": 0.017630821330385515,
+          "allocs_per_call": 1.0,
+          "batch": 15,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.02258890911186675,
+          "p90_ms": 0.02641545453033442,
+          "min_ms": 0.021290272756728384,
+          "mean_ms": 0.023498741821557898,
+          "allocs_per_call": 7.0,
+          "batch": 11,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.24781499996606726,
+          "p90_ms": 0.3554970003278868,
+          "min_ms": 0.17087800006265752,
+          "mean_ms": 0.2606855600970448,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.017749583321347018,
+          "p90_ms": 0.020729166673542448,
+          "min_ms": 0.017085666665176785,
+          "mean_ms": 0.018561523334028607,
+          "allocs_per_call": 1.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0033644999954655455,
+          "p90_ms": 0.004993266672196721,
+          "min_ms": 0.003265899992281144,
+          "mean_ms": 0.0037527933321446954,
+          "allocs_per_call": 1.0,
+          "batch": 30,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.16947149993029598,
+          "p90_ms": 0.20794250008293602,
+          "min_ms": 0.13784199995825475,
+          "mean_ms": 0.17808937996960594,
+          "allocs_per_call": 6.0,
+          "batch": 2,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 50.9
+    },
+    "mnist_cnn": {
+      "regime": "mixed",
+      "input_shape": [
+        1,
+        1,
+        28,
+        28
+      ],
+      "output_shape": [
+        1,
+        10
+      ],
+      "params": 20490,
+      "eager_p50_ms": 0.2853,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.6763806343078613e-07,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.055743285689199444,
+          "p90_ms": 0.06652500003058646,
+          "min_ms": 0.04952471428103828,
+          "mean_ms": 0.05766018284703023,
+          "allocs_per_call": 1.0,
+          "batch": 7,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.09923179995894316,
+          "p90_ms": 0.10984340005961712,
+          "min_ms": 0.09127459998126142,
+          "mean_ms": 0.1005929280036071,
+          "allocs_per_call": 11.0,
+          "batch": 5,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.2613800002109201,
+          "p90_ms": 0.5179720001251553,
+          "min_ms": 0.10913200003415113,
+          "mean_ms": 0.30423748004977824,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.003296730763115472,
+          "p90_ms": 0.004309499987497334,
+          "min_ms": 0.0031892692242343817,
+          "mean_ms": 0.003613452308854903,
+          "allocs_per_call": 1.0,
+          "batch": 26,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.010033588215960395,
+          "p90_ms": 0.012834529410183142,
+          "min_ms": 0.00970976471388199,
+          "mean_ms": 0.010618971762810629,
+          "allocs_per_call": 7.0,
+          "batch": 17,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.46961599991846015,
+          "p90_ms": 0.7049380001262762,
+          "min_ms": 0.20820700001422665,
+          "mean_ms": 0.4628108799988695,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.019205083352365666,
+          "p90_ms": 0.025759500014525354,
+          "min_ms": 0.018011750019771473,
+          "mean_ms": 0.020363603336287874,
+          "allocs_per_call": 1.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0029451935446441866,
+          "p90_ms": 0.0037993870958622036,
+          "min_ms": 0.002880967742619818,
+          "mean_ms": 0.0031116064482991914,
+          "allocs_per_call": 1.0,
+          "batch": 31,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.28986400002395385,
+          "p90_ms": 0.5785360003756068,
+          "min_ms": 0.1575050000610645,
+          "mean_ms": 0.317572640014987,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 44.3
+    },
+    "mobilenet_v2": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 3504872,
+      "eager_p50_ms": 16.7216,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 1.908195823574488e-15,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 7.615194999743835,
+          "p90_ms": 10.984846000155812,
+          "min_ms": 7.284102000085113,
+          "mean_ms": 8.247406960017543,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 14.357416999700945,
+          "p90_ms": 15.884523000295303,
+          "min_ms": 13.103242999932263,
+          "mean_ms": 14.34957443996609,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 3.3920090004357917,
+          "p90_ms": 3.8752400000703346,
+          "min_ms": 2.8352750000522065,
+          "mean_ms": 3.3887396800128045,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.03360787496831108,
+          "p90_ms": 0.03774974999259939,
+          "min_ms": 0.019624999993084202,
+          "mean_ms": 0.03248944500455764,
+          "allocs_per_call": 1.0,
+          "batch": 8,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.02494983334599965,
+          "p90_ms": 0.02989824997712276,
+          "min_ms": 0.022972750002736575,
+          "mean_ms": 0.026185346666049252,
+          "allocs_per_call": 7.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 12.969384999905742,
+          "p90_ms": 14.888038999743003,
+          "min_ms": 11.294765000002371,
+          "mean_ms": 13.238032439949166,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.8455229999526637,
+          "p90_ms": 0.9939289998328604,
+          "min_ms": 0.7047989997772675,
+          "mean_ms": 0.8546242800002801,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0037255714297706227,
+          "p90_ms": 0.004371214312673796,
+          "min_ms": 0.003472642869642836,
+          "mean_ms": 0.00392807428917357,
+          "allocs_per_call": 1.0,
+          "batch": 14,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 5.2553030000126455,
+          "p90_ms": 11.29061300025569,
+          "min_ms": 4.208008999739832,
+          "mean_ms": 6.52389739996579,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 73.8
+    },
+    "resnet18": {
+      "regime": "compute",
+      "input_shape": [
+        1,
+        3,
+        224,
+        224
+      ],
+      "output_shape": [
+        1,
+        1000
+      ],
+      "params": 11689512,
+      "eager_p50_ms": 25.2618,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 2.86102294921875e-06,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 7.481744999950024,
+          "p90_ms": 7.645842000329139,
+          "min_ms": 7.016332000148395,
+          "mean_ms": 7.441481240057328,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 14.106844999787427,
+          "p90_ms": 16.1188699999002,
+          "min_ms": 13.363289999688277,
+          "mean_ms": 14.508839440004522,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 12.557298000047012,
+          "p90_ms": 13.472065000314615,
+          "min_ms": 11.754174999623501,
+          "mean_ms": 12.66011895999327,
+          "allocs_per_call": 3.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.017263500012631994,
+          "p90_ms": 0.023761749957884604,
+          "min_ms": 0.016294750025735993,
+          "mean_ms": 0.018878529999710736,
+          "allocs_per_call": 1.0,
+          "batch": 4,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.024219500043424585,
+          "p90_ms": 0.03153716670567519,
+          "min_ms": 0.022450333365971648,
+          "mean_ms": 0.025302446662559912,
+          "allocs_per_call": 7.0,
+          "batch": 6,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 19.674686000143993,
+          "p90_ms": 21.752858000127162,
+          "min_ms": 18.231892999665433,
+          "mean_ms": 20.004452399989532,
+          "allocs_per_call": 11.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.5262079998828995,
+          "p90_ms": 0.5530509997697663,
+          "min_ms": 0.4882210000687337,
+          "mean_ms": 0.5270785999891814,
+          "allocs_per_call": 1.0,
+          "batch": 1,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.003643149989329686,
+          "p90_ms": 0.00507919999108708,
+          "min_ms": 0.003422700001465273,
+          "mean_ms": 0.003904855998371204,
+          "allocs_per_call": 1.0,
+          "batch": 20,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 13.68511300006503,
+          "p90_ms": 15.697505000389356,
+          "min_ms": 12.560435000068537,
+          "mean_ms": 14.010025680036051,
+          "allocs_per_call": 6.0,
+          "batch": 1,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 36.2
+    },
+    "tiny_mlp": {
+      "regime": "overhead",
+      "input_shape": [
+        1,
+        8
+      ],
+      "output_shape": [
+        1,
+        8
+      ],
+      "params": 72,
+      "eager_p50_ms": 0.0103,
+      "eval": {
+        "passed": true,
+        "max_abs_error": 4.470348358154297e-08,
+        "tolerance": 0.0001
+      },
+      "phases": {
+        "tensor_new_flat": {
+          "p50_ms": 0.016408823525767623,
+          "p90_ms": 0.018919294100616005,
+          "min_ms": 0.015109058842747746,
+          "mean_ms": 0.016775788235998547,
+          "allocs_per_call": 1.0,
+          "batch": 17,
+          "samples": 25
+        },
+        "tensor_new_nested": {
+          "p50_ms": 0.019711857151248426,
+          "p90_ms": 0.023307714302843254,
+          "min_ms": 0.018273428557742073,
+          "mean_ms": 0.020537160005135648,
+          "allocs_per_call": 9.0,
+          "batch": 14,
+          "samples": 25
+        },
+        "forward": {
+          "p50_ms": 0.013725249990178176,
+          "p90_ms": 0.02174308334209248,
+          "min_ms": 0.013142083313747813,
+          "mean_ms": 0.015548490005130589,
+          "allocs_per_call": 3.0,
+          "batch": 12,
+          "samples": 25
+        },
+        "to_a_flat": {
+          "p50_ms": 0.0032424705911099035,
+          "p90_ms": 0.003857117650006651,
+          "min_ms": 0.0031533529413447434,
+          "mean_ms": 0.0034102368619071555,
+          "allocs_per_call": 1.0,
+          "batch": 51,
+          "samples": 25
+        },
+        "to_a_nested": {
+          "p50_ms": 0.01032916666569387,
+          "p90_ms": 0.012724333335730384,
+          "min_ms": 0.009599041675301123,
+          "mean_ms": 0.011090219998095563,
+          "allocs_per_call": 7.0,
+          "batch": 24,
+          "samples": 25
+        },
+        "e2e": {
+          "p50_ms": 0.05123566666043189,
+          "p90_ms": 0.05806633331909931,
+          "min_ms": 0.0473043332931411,
+          "mean_ms": 0.05296417999488767,
+          "allocs_per_call": 11.0,
+          "batch": 6,
+          "samples": 25
+        },
+        "tensor_from_bytes": {
+          "p50_ms": 0.015848954531479238,
+          "p90_ms": 0.019607818186076736,
+          "min_ms": 0.01486345453568819,
+          "mean_ms": 0.016334245452857103,
+          "allocs_per_call": 1.0,
+          "batch": 22,
+          "samples": 25
+        },
+        "to_binary": {
+          "p50_ms": 0.0034039090905935154,
+          "p90_ms": 0.004178636355721789,
+          "min_ms": 0.0029006590900528617,
+          "mean_ms": 0.003480430909390138,
+          "allocs_per_call": 1.0,
+          "batch": 44,
+          "samples": 25
+        },
+        "e2e_binary": {
+          "p50_ms": 0.039294000013493736,
+          "p90_ms": 0.045951000023099674,
+          "min_ms": 0.03754266663236194,
+          "mean_ms": 0.041629533331312515,
+          "allocs_per_call": 6.0,
+          "batch": 6,
+          "samples": 25
+        }
+      },
+      "binding_overhead_pct": 73.2
+    }
+  }
+}
\ No newline at end of file

From 457342c229d50cbd25920b5dba8a1c09e8a624f5 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 5 Aug 2026 05:22:38 +0000
Subject: [PATCH 5/7] fix: accept comma-separated names in make_pt_models.py
 --models

--models add_mul,mnist_cnn was read as one model name and failed with an
unknown-model error. Split on commas as well as spaces.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACSJ1DPT6ryZy6gdvnaJ5K
---
 bench/make_pt_models.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/bench/make_pt_models.py b/bench/make_pt_models.py
index dbe2024..7ea70a9 100644
--- a/bench/make_pt_models.py
+++ b/bench/make_pt_models.py
@@ -103,7 +103,11 @@ def build(name, out_dir):
 
 def main():
     ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--models", nargs="*", help="model names (default: the standard set)")
+    ap.add_argument(
+        "--models",
+        nargs="*",
+        help="model names, space- or comma-separated (default: the standard set)",
+    )
     ap.add_argument("--all", action="store_true", help="build every registered model")
     ap.add_argument("--out", default=MODELS_DIR)
     args = ap.parse_args()
@@ -111,7 +115,7 @@ def main():
     if args.all:
         names = list(bench_models.REGISTRY)
     elif args.models:
-        names = args.models
+        names = [n for arg in args.models for n in arg.split(",") if n]
     else:
         names = bench_models.DEFAULT_MODELS
 

From b8bd0da225ebc78049f0d71c24cc89eb3ea12f9f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 7 Aug 2026 02:15:16 +0000
Subject: [PATCH 6/7] ci: add CI and release workflows, and a working
 ExecuTorch build script

The documented install path did not actually work. `cmake --install` does
not install extension/module/module.h or the runtime/executor headers, both
of which this gem includes directly, so `rake compile` failed with
"module.h header not found" on a perfectly good ExecuTorch build. Anyone
following the README hit this.

- script/build-executorch.sh: clone at a pinned version, fetch submodules,
  fetch the matching buck2 (ExecuTorch's CMake shells out to it to generate
  source lists), configure, build, install, then copy the ~1300 headers the
  install step leaves behind. Verified end to end: a fresh prefix built by
  this script compiles the extension and passes all 70 tests.
  EXECUTORCH_BACKENDS=xnnpack opts into the delegate.
- .executorch-version: single source of truth, shared with CI's cache key.
- Rakefile: executorch:build_deps delegates to the script rather than
  keeping a second copy of the cmake flags.

- .github/workflows/ci.yml: lint (Ruby/shell syntax, gem packaging,
  CHANGELOG entry) plus tests on Ruby 3.1-3.4 on Linux and 3.3 on macOS.
  ExecuTorch is built once per OS and cached, since a cold build is tens of
  minutes; the test matrix restores that cache rather than rebuilding per
  Ruby version. Both jobs compute the cache key with the same expression.
- .github/workflows/release.yml: on a v* tag, verify the tag matches
  Executorch::VERSION and that the CHANGELOG has an entry, build the gem,
  check the extension sources are actually in the package, publish via
  RubyGems trusted publishing (OIDC, no API key in secrets), and cut a
  GitHub release. workflow_dispatch runs it as a dry run.

- CHANGELOG: Unreleased section covering this branch. Version bump left to
  the maintainer.
- README: install steps point at the script; troubleshooting explains the
  real cause of the header error; CI badge.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACSJ1DPT6ryZy6gdvnaJ5K
---
 .executorch-version           |   1 +
 .github/workflows/ci.yml      | 128 +++++++++++++++++++++++++
 .github/workflows/release.yml |  94 +++++++++++++++++++
 CHANGELOG.md                  |  35 +++++++
 README.md                     |  47 ++++++----
 Rakefile                      |  28 +-----
 script/build-executorch.sh    | 172 ++++++++++++++++++++++++++++++++++
 7 files changed, 463 insertions(+), 42 deletions(-)
 create mode 100644 .executorch-version
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 .github/workflows/release.yml
 create mode 100755 script/build-executorch.sh

diff --git a/.executorch-version b/.executorch-version
new file mode 100644
index 0000000..8b20e48
--- /dev/null
+++ b/.executorch-version
@@ -0,0 +1 @@
+v0.7.0
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..a14db2d
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,128 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # ---------------------------------------------------------------------------
+  # Cheap checks that don't need a native build, so obvious mistakes fail fast.
+  # ---------------------------------------------------------------------------
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: false
+
+      - name: Check Ruby syntax
+        run: |
+          find lib test bench -name '*.rb' -print0 \
+            | xargs -0 -n1 ruby -c > /dev/null
+          ruby -c Rakefile > /dev/null
+          ruby -c ext/executorch/extconf.rb > /dev/null
+
+      - name: Check shell syntax
+        run: bash -n script/build-executorch.sh
+
+      - name: Build the gem package
+        run: gem build executorch.gemspec
+
+      - name: Version matches CHANGELOG
+        run: |
+          version=$(ruby -r./lib/executorch/version -e 'print Executorch::VERSION')
+          grep -q "## \[$version\]" CHANGELOG.md \
+            || { echo "CHANGELOG.md has no entry for $version"; exit 1; }
+
+  # ---------------------------------------------------------------------------
+  # ExecuTorch takes a long time to build, so build it once per OS and cache it.
+  # The test matrix restores that cache instead of rebuilding per Ruby version.
+  # ---------------------------------------------------------------------------
+  executorch:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      # Same expression as the test job below -- they must agree or the test
+      # job restores nothing.
+      - name: Restore ExecuTorch
+        id: cache
+        uses: actions/cache@v4
+        with:
+          path: vendor/executorch
+          key: executorch-${{ matrix.os }}-${{ hashFiles('.executorch-version', 'script/build-executorch.sh') }}
+
+      - name: Install build tools
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: |
+          python3 -m pip install --upgrade "cmake>=3.29" zstd
+          if [ "$RUNNER_OS" = "Linux" ]; then
+            sudo apt-get update && sudo apt-get install -y ninja-build
+          else
+            brew install ninja
+          fi
+
+      - name: Build ExecuTorch
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: script/build-executorch.sh
+        env:
+          # Portable kernels only: correct, and enough to test the bindings.
+          # The XNNPACK delegate is what you want in production (see
+          # bench/FINDINGS.md) but roughly triples the build time.
+          EXECUTORCH_BACKENDS: none
+
+  test:
+    needs: executorch
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        ruby: ["3.1", "3.2", "3.3", "3.4"]
+        include:
+          - os: macos-latest
+            ruby: "3.3"
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Restore ExecuTorch
+        uses: actions/cache/restore@v4
+        with:
+          path: vendor/executorch
+          key: executorch-${{ matrix.os }}-${{ hashFiles('.executorch-version', 'script/build-executorch.sh') }}
+          fail-on-cache-miss: true
+
+      # A partial restore would be worse than none: an install built by an older
+      # script can be missing headers the extension needs.
+      - name: Verify the install is usable
+        run: |
+          test -f vendor/executorch/include/executorch/extension/module/module.h \
+            || { echo "ExecuTorch install is incomplete"; exit 1; }
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: Compile
+        run: bundle exec rake compile
+        env:
+          EXECUTORCH_DIR: ${{ github.workspace }}/vendor/executorch
+
+      - name: Test
+        run: bundle exec rake test
+        env:
+          EXECUTORCH_DIR: ${{ github.workspace }}/vendor/executorch
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..28ac387
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,94 @@
+name: Release
+
+# Publishes to RubyGems when a v* tag is pushed:
+#
+#   1. bump Executorch::VERSION and add a CHANGELOG entry
+#   2. git tag v0.2.0 && git push origin v0.2.0
+#
+# Publishing uses RubyGems trusted publishing (OIDC), so there is no API key in
+# repository secrets. Set it up once at
+# https://rubygems.org/gems/executorch/trusted_publishers with:
+#
+#   repository:  benngarcia/executorch-ruby
+#   workflow:    release.yml
+#   environment: release
+#
+# This ships a source gem -- the C++ extension is compiled on the user's
+# machine at install time against their own ExecuTorch build, so no
+# cross-compilation matrix is needed here.
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: "Build and verify without publishing"
+        type: boolean
+        default: true
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: release
+
+    permissions:
+      contents: write # create the GitHub release
+      id-token: write # OIDC token for trusted publishing
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: false
+
+      - name: Check the tag matches Executorch::VERSION
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          version=$(ruby -r./lib/executorch/version -e 'print Executorch::VERSION')
+          tag="${GITHUB_REF#refs/tags/v}"
+          if [ "$version" != "$tag" ]; then
+            echo "Tag v$tag does not match Executorch::VERSION ($version)." >&2
+            echo "Bump lib/executorch/version.rb, or retag." >&2
+            exit 1
+          fi
+          echo "version=$version" >> "$GITHUB_ENV"
+
+      - name: Check the CHANGELOG has an entry
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          grep -q "## \[$version\]" CHANGELOG.md \
+            || { echo "CHANGELOG.md has no entry for $version"; exit 1; }
+
+      - name: Build the gem
+        run: gem build executorch.gemspec
+
+      # Catch a packaging mistake before it reaches RubyGems: the extension
+      # sources must be in the gem or it cannot build on install.
+      - name: Verify the package contents
+        run: |
+          gem_file=$(ls executorch-*.gem)
+          for required in \
+            ext/executorch/extconf.rb \
+            ext/executorch/executorch.cpp \
+            ext/executorch/utils.h \
+            lib/executorch.rb \
+            LICENSE.txt
+          do
+            tar -xOf "$gem_file" data.tar.gz | tar -tzf - | grep -qx "$required" \
+              || { echo "Missing from gem package: $required"; exit 1; }
+          done
+          echo "Package contents OK"
+
+      - name: Publish to RubyGems
+        if: startsWith(github.ref, 'refs/tags/') && !inputs.dry_run
+        uses: rubygems/release-gem@v1
+
+      - name: Create the GitHub release
+        if: startsWith(github.ref, 'refs/tags/') && !inputs.dry_run
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          files: executorch-*.gem
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 625ced1..c172af6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- `Tensor.from_bytes(packed, shape:, dtype:)` and `Tensor#to_binary` - raw
+  binary tensor I/O that skips per-element conversion. Roughly 174x faster than
+  the Array constructor on a 150k-element input.
+- `bench/` - eval and profiling harness. Converts `.pt` checkpoints to `.pte`,
+  checks output against PyTorch, and times each leg of an inference call. See
+  `bench/FINDINGS.md`.
+- `script/build-executorch.sh` - reproducible ExecuTorch build used by both
+  humans and CI.
+- CI (GitHub Actions) for lint and tests across Ruby 3.1-3.4 on Linux and
+  macOS, plus a tag-triggered RubyGems release workflow.
+
+### Changed
+
+- Large reduction in Ruby/C++ boundary cost. Tensor creation is ~13x faster,
+  `#to_a` up to ~65x faster, and building a tensor from a nested Array now
+  allocates 11 objects instead of 153,238 for a 150k-element input.
+- `extconf.rb` now links optimized CPU kernels and the XNNPACK delegate when
+  they are present in the ExecuTorch install, whole-archiving them so their
+  self-registration is not dropped by the linker.
+
+### Fixed
+
+- The documented install path did not work: `cmake --install` does not install
+  `extension/module/module.h` or the `runtime/executor` headers, so
+  `rake compile` failed with "module.h header not found" on a correct build.
+  `script/build-executorch.sh` copies them.
+- `extconf.rb` whole-archived two operator libraries when both were present,
+  which aborts the runtime at init on duplicate operator registration.
+- Build failure against Rice 4.12, where `Rice::Array::Proxy` no longer
+  converts implicitly to `Rice::Object`.
+
 ## [0.1.0] - 2024-12-27
 
 ### Added
diff --git a/README.md b/README.md
index aaeff57..c691b87 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # ExecuTorch Ruby
 
+[![CI](https://github.com/benngarcia/executorch-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/benngarcia/executorch-ruby/actions/workflows/ci.yml)
+
 Run PyTorch models in Ruby.
 
 [ExecuTorch](https://pytorch.org/executorch/) is Meta's lightweight runtime for deploying PyTorch models on edge devices. This gem provides Ruby bindings so you can run exported models (`.pte` files) directly in your Ruby applications.
@@ -26,24 +28,28 @@ puts output.to_a  # => [[3.0, 5.0, 7.0]]
 
 ### Step 1: Build ExecuTorch
 
-ExecuTorch must be built from source. Follow the [official guide](https://pytorch.org/executorch/stable/getting-started-setup.html), or use these commands:
+ExecuTorch must be built from source. This repo ships a script that does it:
 
 ```bash
-git clone https://github.com/pytorch/executorch.git
-cd executorch
-./install_requirements.sh
+script/build-executorch.sh
+```
 
-cmake -B cmake-out \
-  -DCMAKE_INSTALL_PREFIX=vendor/executorch \
-  -DEXECUTORCH_BUILD_EXTENSION_MODULE=ON \
-  -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON \
-  -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON \
-  -DCMAKE_BUILD_TYPE=Release
+It clones ExecuTorch at a pinned version, builds it, installs into
+`vendor/executorch`, and copies the headers that `cmake --install` leaves
+behind (`extension/module/module.h` and the `runtime/executor` tree are not
+installed by ExecuTorch's own install step, and this gem includes them
+directly).
+
+Add the XNNPACK delegate — strongly recommended, see [Performance](#performance)
+— with:
 
-cmake --build cmake-out -j4
-cmake --install cmake-out
+```bash
+EXECUTORCH_BACKENDS=xnnpack script/build-executorch.sh
 ```
 
+Needs CMake ≥ 3.29, Ninja, and a C++17 compiler. The first build takes a while;
+the ExecuTorch source and submodules are several GB.
+
 ### Step 2: Install the Gem
 
 Tell Bundler where ExecuTorch is installed (only needed once per project):
@@ -201,15 +207,20 @@ bundle config set --local build.executorch --with-executorch-dir=vendor/executor
 <details>
 <summary><strong>"module.h header not found"</strong></summary>
 
-ExecuTorch was built without required extensions. Rebuild with:
+Usually not a missing build flag — `cmake --install` doesn't install
+`extension/module/module.h` at all, even on a correct build. If you built
+ExecuTorch by hand, copy the remaining headers across:
 
 ```bash
-cmake -B cmake-out \
-  -DEXECUTORCH_BUILD_EXTENSION_MODULE=ON \
-  -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON \
-  -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON \
-  ...
+cd /path/to/executorch
+find runtime kernels extension -name '*.h' -not -path '*/test/*' \
+  | while read -r f; do
+      mkdir -p "$PREFIX/include/executorch/$(dirname "$f")"
+      cp "$f" "$PREFIX/include/executorch/$f"
+    done
 ```
+
+Or just use `script/build-executorch.sh`, which handles it.
 </details>
 
 <details>
diff --git a/Rakefile b/Rakefile
index 855bdc7..2041edf 100644
--- a/Rakefile
+++ b/Rakefile
@@ -17,30 +17,10 @@ task default: %i[compile test]
 namespace :executorch do
   desc 'Build ExecuTorch from source and install to vendor/executorch'
   task :build_deps do
-    source_dir = ENV.fetch('EXECUTORCH_SRC', File.expand_path('../executorch', __dir__))
-    install_dir = File.expand_path('vendor/executorch', __dir__)
-
-    unless File.directory?(source_dir)
-      abort "ExecuTorch source not found at #{source_dir}. Clone it or set EXECUTORCH_SRC."
-    end
-
-    puts "Building ExecuTorch from #{source_dir}..."
-    puts "Installing to #{install_dir}..."
-
-    Dir.chdir(source_dir) do
-      system('cmake', '-B', 'cmake-out',
-             "-DCMAKE_INSTALL_PREFIX=#{install_dir}",
-             '-DEXECUTORCH_BUILD_EXTENSION_MODULE=ON',
-             '-DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON',
-             '-DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON',
-             '-DCMAKE_BUILD_TYPE=Release') || abort('CMake configure failed')
-
-      system('cmake', '--build', 'cmake-out', "-j#{Etc.nprocessors}") || abort('CMake build failed')
-      system('cmake', '--install', 'cmake-out') || abort('CMake install failed')
-    end
-
-    puts "ExecuTorch installed to #{install_dir}"
-    puts "Run: bundle config set --local build.executorch --with-executorch-dir=#{install_dir}"
+    # Delegates to the script so this task, the README, and CI all build
+    # ExecuTorch exactly the same way. Set EXECUTORCH_BACKENDS=xnnpack to
+    # include the delegate.
+    sh File.expand_path('script/build-executorch.sh', __dir__)
   end
 end
 
diff --git a/script/build-executorch.sh b/script/build-executorch.sh
new file mode 100755
index 0000000..a6da816
--- /dev/null
+++ b/script/build-executorch.sh
@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+#
+# Build ExecuTorch from source and install it where this gem can find it.
+#
+# Usage:
+#   script/build-executorch.sh
+#   EXECUTORCH_BACKENDS=xnnpack script/build-executorch.sh
+#
+# Environment:
+#   EXECUTORCH_VERSION   git tag to build           (default: v0.7.0)
+#   EXECUTORCH_SRC       where to clone the source  (default: ./tmp/executorch-src/executorch)
+#   INSTALL_PREFIX       where to install           (default: ./vendor/executorch)
+#   EXECUTORCH_BACKENDS  comma-separated: xnnpack   (default: none)
+#   JOBS                 parallel build jobs        (default: detected)
+#
+# Afterwards:
+#   bundle config set --local build.executorch --with-executorch-dir="$PWD/vendor/executorch"
+#   bundle exec rake compile
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+# Single source of truth for the version, shared with CI's cache key.
+EXECUTORCH_VERSION="${EXECUTORCH_VERSION:-$(cat "$REPO_ROOT/.executorch-version")}"
+EXECUTORCH_SRC="${EXECUTORCH_SRC:-$REPO_ROOT/tmp/executorch-src/executorch}"
+INSTALL_PREFIX="${INSTALL_PREFIX:-$REPO_ROOT/vendor/executorch}"
+EXECUTORCH_BACKENDS="${EXECUTORCH_BACKENDS:-none}"
+JOBS="${JOBS:-$(getconf _NPROCESSORS_ONLN 2>/dev/null || echo 4)}"
+
+BUILD_DIR="$EXECUTORCH_SRC/cmake-out"
+
+log() { printf '\n==> %s\n' "$*"; }
+
+# -----------------------------------------------------------------------------
+# Prerequisites
+# -----------------------------------------------------------------------------
+
+# ExecuTorch's CMakeLists requires the checkout to be in a directory named
+# exactly "executorch" (pytorch/executorch#6475).
+if [ "$(basename "$EXECUTORCH_SRC")" != "executorch" ]; then
+  echo "EXECUTORCH_SRC must end in a directory named 'executorch', got: $EXECUTORCH_SRC" >&2
+  exit 1
+fi
+
+cmake_version="$(cmake --version | head -1 | awk '{print $3}')"
+required_cmake="3.29"
+if [ "$(printf '%s\n%s\n' "$required_cmake" "$cmake_version" | sort -V | head -1)" != "$required_cmake" ]; then
+  echo "ExecuTorch needs CMake >= $required_cmake, found $cmake_version." >&2
+  echo "Install a newer one, e.g.: pip install 'cmake>=3.29'" >&2
+  exit 1
+fi
+
+# -----------------------------------------------------------------------------
+# Source
+# -----------------------------------------------------------------------------
+
+if [ ! -d "$EXECUTORCH_SRC/.git" ]; then
+  log "Cloning ExecuTorch $EXECUTORCH_VERSION"
+  mkdir -p "$(dirname "$EXECUTORCH_SRC")"
+  git clone --depth 1 --branch "$EXECUTORCH_VERSION" \
+    https://github.com/pytorch/executorch.git "$EXECUTORCH_SRC"
+fi
+
+log "Fetching submodules (this is the slow part on a cold checkout)"
+git -C "$EXECUTORCH_SRC" submodule update --init --recursive --depth 1 --jobs "$JOBS"
+
+# ExecuTorch's CMake shells out to buck2 to generate its source lists, and the
+# version has to match the pin in the checkout.
+if ! command -v buck2 >/dev/null 2>&1; then
+  buck2_pin="$(cat "$EXECUTORCH_SRC/.ci/docker/ci_commit_pins/buck2.txt")"
+  log "Installing buck2 $buck2_pin"
+
+  case "$(uname -s)" in
+    Darwin) buck2_arch="aarch64-apple-darwin" ;;
+    *)      buck2_arch="x86_64-unknown-linux-musl" ;;
+  esac
+
+  buck2_dir="$REPO_ROOT/tmp/bin"
+  mkdir -p "$buck2_dir"
+  curl -sSL -o "$buck2_dir/buck2.zst" \
+    "https://github.com/facebook/buck2/releases/download/${buck2_pin}/buck2-${buck2_arch}.zst"
+
+  if command -v zstd >/dev/null 2>&1; then
+    zstd -d -f "$buck2_dir/buck2.zst" -o "$buck2_dir/buck2"
+  else
+    python3 -c "
+import sys, zstd
+open(sys.argv[2], 'wb').write(zstd.decompress(open(sys.argv[1], 'rb').read()))
+" "$buck2_dir/buck2.zst" "$buck2_dir/buck2"
+  fi
+
+  chmod +x "$buck2_dir/buck2"
+  export PATH="$buck2_dir:$PATH"
+fi
+
+# -----------------------------------------------------------------------------
+# Configure and build
+# -----------------------------------------------------------------------------
+
+cmake_args=(
+  -B "$BUILD_DIR"
+  -S "$EXECUTORCH_SRC"
+  "-DBUCK2=$(command -v buck2)"
+  "-DCMAKE_INSTALL_PREFIX=$INSTALL_PREFIX"
+  -DCMAKE_BUILD_TYPE=Release
+  -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+  -DEXECUTORCH_BUILD_EXTENSION_MODULE=ON
+  -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON
+  -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON
+  -DEXECUTORCH_BUILD_EXTENSION_FLAT_TENSOR=ON
+  -DEXECUTORCH_BUILD_PTHREADPOOL=ON
+  -DEXECUTORCH_BUILD_CPUINFO=ON
+)
+
+if [[ ",$EXECUTORCH_BACKENDS," == *",xnnpack,"* ]]; then
+  # Worth ~658x on resnet18 -- see bench/FINDINGS.md. Costs a much longer build,
+  # and models must also be exported through XnnpackPartitioner to benefit.
+  log "Including the XNNPACK delegate"
+  cmake_args+=(-DEXECUTORCH_BUILD_XNNPACK=ON)
+fi
+
+command -v ninja >/dev/null 2>&1 && cmake_args+=(-G Ninja)
+
+log "Configuring"
+cmake "${cmake_args[@]}"
+
+log "Building with $JOBS jobs"
+cmake --build "$BUILD_DIR" -j "$JOBS"
+
+log "Installing to $INSTALL_PREFIX"
+cmake --install "$BUILD_DIR"
+
+# -----------------------------------------------------------------------------
+# Headers
+# -----------------------------------------------------------------------------
+#
+# `cmake --install` only installs a subset of ExecuTorch's headers -- notably
+# not extension/module/module.h or anything under runtime/executor, both of
+# which this gem includes directly. Without these, `rake compile` fails with
+# "module.h header not found" even though the install looks complete.
+#
+# Copy the rest out of the source tree, preserving the layout the headers
+# #include each other by.
+
+log "Copying headers the install step leaves behind"
+header_root="$INSTALL_PREFIX/include/executorch"
+copied=0
+while IFS= read -r header; do
+  dest="$header_root/$header"
+  mkdir -p "$(dirname "$dest")"
+  cp "$EXECUTORCH_SRC/$header" "$dest"
+  copied=$((copied + 1))
+done < <(cd "$EXECUTORCH_SRC" && find runtime kernels extension \
+           -name '*.h' -not -path '*/test/*' -not -path '*/testing_util/*')
+
+log "Copied $copied headers"
+
+if [ ! -f "$header_root/extension/module/module.h" ]; then
+  echo "Expected $header_root/extension/module/module.h to exist; build looks incomplete." >&2
+  exit 1
+fi
+
+cat <<EOF
+
+ExecuTorch $EXECUTORCH_VERSION installed to $INSTALL_PREFIX
+
+Next:
+  bundle config set --local build.executorch --with-executorch-dir="$INSTALL_PREFIX"
+  bundle exec rake compile
+  bundle exec rake test
+EOF

From 4a913982a5cc51160ce42797a175a43cf2397d05 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 7 Aug 2026 02:16:26 +0000
Subject: [PATCH 7/7] fix: target master, not main

The default branch is master. The CI push trigger and the gemspec's
changelog_uri both assumed main, so CI would never have run on pushes to
the default branch and the changelog link would 404 on rubygems.org.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ACSJ1DPT6ryZy6gdvnaJ5K
---
 .github/workflows/ci.yml | 2 +-
 executorch.gemspec       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a14db2d..64c13ed 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,7 +2,7 @@ name: CI
 
 on:
   push:
-    branches: [main]
+    branches: [master]
   pull_request:
   workflow_dispatch:
 
diff --git a/executorch.gemspec b/executorch.gemspec
index 47e4504..be014ac 100644
--- a/executorch.gemspec
+++ b/executorch.gemspec
@@ -28,6 +28,6 @@ Gem::Specification.new do |spec|
   spec.metadata = {
     'homepage_uri' => spec.homepage,
     'source_code_uri' => spec.homepage,
-    'changelog_uri' => "#{spec.homepage}/blob/main/CHANGELOG.md"
+    'changelog_uri' => "#{spec.homepage}/blob/master/CHANGELOG.md"
   }
 end