Performance

go-ruby-rack/rack is the pure-Go library that rbgo binds for Ruby’s rack. This page records the module’s place in the ecosystem-wide per-module parity suite: the same Ruby-visible operation is run through the pure-Go library and through each reference runtime’s own rack gem; the Go output is verified byte-identical to MRI first, then timed.

The harness lives under benchmarks/ in this repository — a self-contained Go driver that pins the published library by pseudo-version (no replace), the equivalent Ruby workload over the real rack gem, and a run.sh that gates on byte-identical parity before timing.

Setup

Method. Each process runs 3 untimed warm-up passes (to let the JVM/GraalVM JITs warm up), then 25 timed passes of a fixed inner loop, timed with a monotonic clock; the best pass is reported as ns/op (best, not mean, to suppress scheduler noise). Interpreter start-up is outside the timed region. Every op’s output is checked byte-identical to MRI before any timing is recorded — the structural ops (parse_*, request, response) through a length-prefixed canonical serialiser shared by the Go and Ruby drivers.

Headline: pure-Go vs MRI + YJIT

Rack’s compute surface is pure Ruby, so the pure-Go port is broadly far ahead of even the JIT. go-ruby-rack beats MRI + YJIT on all 9 ops. The closest race is escape_html, where Rack::Utils.escape_html dispatches into a C-implemented core (cgi/escape): a two-pass strings.Replacer used to lose to it, but the table-driven single-pass escaper (a 256-entry byte→entity lookup that bulk-copies verbatim runs and returns no-escape input allocation-free) now runs ~1.5× ahead of even YJIT’s C path.

Full results

Nine representative primitives from Rack’s pure-compute surface, over fixed inputs present in both go-ruby-rack and rack 3.2.6. (unescape_html is omitted — it is not part of Rack::Utils 3.2.6.) vs MRI is the ratio to plain MRI (lower is faster).

escape

Rack::Utils.escape — form-encode a realistic value (spaces, reserved bytes, multi-byte UTF-8).

unescape

Rack::Utils.unescape — the inverse of escape.

escape_html

Rack::Utils.escape_html — the five-character HTML-entity escape (&, <, >, ", '). MRI/YJIT dispatch to a C core (cgi/escape) here, so this is the closest race — and the pure-Go table-driven escaper now wins it outright.

parse_query

Rack::Utils.parse_query — a flat query string (repeated array keys, %/+ values, a valueless key) into a key → value(s) map.

build_query

Rack::Utils.build_query — the inverse of parse_query.

parse_nested_query

Rack::Utils.parse_nested_query — a foo[bar][]=… nested body into structural Hash/Array/String/nil.

build_nested_query

Rack::Utils.build_nested_query — the inverse of parse_nested_query.

request

Build a Rack::Request from a fixed env Hash and read a fixed set of accessors (request_method, host, port, scheme, ssl?, media_type, xhr?, url, …).

response

Build a Rack::Response, write a body, and finish it into the SPEC [status, headers, body] tuple (content-length filled in).

Reproduce

bash benchmarks/run.sh

The script re-verifies byte-identical parity with MRI, then re-runs every available runtime. Knobs: OUTER (timed passes, default 25), WARM (warm-up passes, default 3), and RUBY/JRUBY/TRUFFLERUBY to select binaries.