A port of ONCE Campfire to Ruby 4.0.7 without Rails: Falcon serving from worker Ractors in a single process, plain modules over SQLite, and in-process job and cable Ractors joined by message passing. It reads the Rails app's SQLite database, storage layout and signed/encrypted cookies unchanged, and aims for byte-identical HTML to the Rails app, apart from a few deliberate differences.
This is an experiment in how fast idiomatic-but-careful Ruby can serve a real Rails app's workload once the framework is gone. It stands on three reference repositories:
| Repository | Role here |
|---|---|
| basecamp/once-campfire | The source of truth. Behavior, routes, views, assets, schema and cookie formats are ported from it; every page is diffed against it. public/assets is its compiled frontend. |
| basecamp/once-campfire-go | The architecture. No framework, ORM or Redis: one module per concern over SQLite, in-process queues and an in-process Action Cable hub. Here the queues are Ractors. |
| basecamp/once-campfire-rust | The harness. Its parity suite (seeds, parity/bin/reference, parity/bin/candidate compare), its load generator and bench/run, its fixed test environment (parity/.env.reference), and its list of deliberate differences from Rails. |
- Parity: before the deliberate differences below, passed the Rust repo's full parity suite against the Rails reference (HTML, DOM, accessibility trees, assets, Cable frames, screenshots): default seed 874/874, crowd 25/25, custom_styles 33/33, first_run 16/16, restricted 8/8. The suite has not been rerun since.
- Not production-hardened. No TLS/ACME front server (run it behind a proxy), no backup hooks, and no upgrade testing beyond sharing the seed databases with Rails, Go and Rust.
- Jobs (push, webhooks, unfurls, media) are in-process like the Go and Rust ports: queued jobs are lost on a crash.
These follow the Rust port's known differences:
- CSRF:
Sec-Fetch-Sitereplaces authenticity tokens, as Rails main'sprotect_from_forgery using: :header_onlydoes. Writes acceptsame-originandsame-site, rejectcross-siteand missing headers with 422, and keep theOrigincheck. WithDISABLE_SSLset (plain HTTP), a missing header is accepted over HTTP (theSameSite=Laxcookies protect it). Pages carry no csrf-token meta tag orauthenticity_tokenfields, so a page renders the same until what it shows changes. HTTPS forms need a browser that sends the header (Safari 16.4 or newer).app/assets/overridesholds the one frontend change this needs. - Caching: HTML ETags hash the page's parts and repeat until the page changes, so revalidation gets a 304. Every part of a page (cached fragments and the layout between them) is compressed once and kept; a page without fragments keeps its gzip by body digest.
- Cookies: the session cookie is written only when the session changed, and deleted when it is
empty.
session_tokenis re-signed with the hourly activity refresh instead of on every request (its 20-year expiry keeps rolling);last_roomis set only when it changes. - Routes:
/rooms/directs/:idredirects to the room instead of answering 500.
Unmodified production images, the Rust repo's default seed and bench/run-all (its bench/run
plus Go and Ruby). Each app gets 4 pinned hardware threads (CPUs 8-11) on an AMD Ryzen Threadripper
PRO 7975WX, the load generator another 4. Medians of three interleaved reps on October 5, 2026, before
the deliberate differences above:
Rails/Rust/Ruby report,
Go/Rust/Ruby report.
| Route | Rails | Go | Rust | Ruby | Ruby vs Rails |
|---|---|---|---|---|---|
| Room page | 189 req/s | 3,152 | 20,976 | 5,094 | 27× |
| Messages page | 335 | 4,096 | 23,034 | 8,499 | 25× |
| Sidebar | 480 | 11,927 | 20,182 | 7,235 | 15× |
| Search | 334 | 5,412 | 19,871 | 6,959 | 21× |
| Post a message | 199 | 1,077 | 2,713 | 1,810 | 9× |
/up |
3,436 | 79,600 | 118,724 | 61,370 | 18× |
| Measurement | Rails | Go | Rust | Ruby |
|---|---|---|---|---|
| Room page p99, 64 clients | 503 ms | 67 ms | 5.6 ms | 26 ms |
| Post a message p99, 1 client | 28 ms | 26 ms | 6.4 ms | 3.3 ms |
| Post a message p99, 64 clients | 2,208 ms | 409 ms | 60 ms | 201 ms |
| Cable deliveries/s, 100 clients | 72 | 665 | 1,807 | 1,094 |
| Cable deliveries/s, 1,000 clients | 11 | 140 | 431 | 117 |
| Upload until thumbnail served | 79 ms | 36 ms | 42 ms | 234 ms |
Cold start until /up |
4.6 s | 0.5 s | 0.5 s | 2.9 s |
| Idle / peak container memory | 439 / 1,526 MB | 44 / 413 MB | 29 / 357 MB | 82 / 1,162 MB |
The Go numbers come from the Go/Rust/Ruby run; Rust and Ruby agreed within a few percent between the two runs. Known weak spots: uploads (slower than Rails), cable p99 at 500+ clients (it varies between runs from tens to hundreds of milliseconds) and peak memory.
On Ruby master. The same app on a build of ruby/ruby master (Dockerfile.head,
report) is 1.2× faster on the room page and 1.5× on the messages page. It
delivers 1.6–2.2× more cable messages at 500–1,000 clients, and peaks at 723 MB instead of 1,247 MB. ZJIT
(bench/run-all --apps ruby-zjit) works with Ractors and runs 3–6% behind YJIT on the pages
(report; each rep's boot log confirms JIT: ZJIT).
An animated explainer, docs/explainer.html (open it locally in a browser), walks through the architecture, the decisions and where the speed
comes from. The porting guide has the details and the rules; in short:
- Ractors, not processes.
WEB_CONCURRENCYworker Ractors each run a Falcon/Async reactor on a shared listening socket, with their own SQLite connection and fragment cache. Jobs run inJOB_CONCURRENCYjob Ractors; Action Cable broadcasts go through a Bus Ractor. There is no Redis: messages between Ractors are frozen arrays of integers and strings. - One writer. A writer Ractor hands out SQLite's write permit in arrival order
(
writer.rb).Connection#transactiontakes it transparently, and only the waiting fiber suspends. Rails'touch: true, unread marking, dependent deletes and search trimming are SQLite triggers (db/triggers.sql), so a post is one short transaction. WAL checkpoints run on a background thread instead of inside a request's COMMIT. - Reads in one snapshot. Every GET runs inside one read transaction, which makes each query about 20× cheaper than autocommit.
- Rendering without allocation. ERB templates compile to methods that append into one
pre-sized String per response. Rails-style fragment caches are per Ractor, and gzipped pages are
spliced together from pre-compressed parts (
page_parts.rb). - Rails wire contracts, not Rails. Signed/encrypted cookies, signed ids, Active Storage URLs,
the Action Cable protocol and Turbo Streams are reimplemented where the browser or the database
can see them (
lib/campfire/rails_compat), and nowhere else. - Patched Extralite.
vendor/gems/extralitefixes two crashes (finalizing FTS5 statements on close, and reusing a statement freed by a failedexecute).
Build the image (same contract as the Rails, Go and Rust images: HTTP on $HTTP_PORT, state in
/rails/storage/{db,files}, uid 1000):
docker build -t campfire-ruby:app .
docker run -d -p 3000:80 \
-e SECRET_KEY_BASE=... -e VAPID_PUBLIC_KEY=... -e VAPID_PRIVATE_KEY=... \
-e WEB_CONCURRENCY=8 -e JOB_CONCURRENCY=2 \
-v campfire:/rails/storage campfire-ruby:appIt serves plain HTTP only; put a TLS proxy in front. An empty database gets the Rails schema on first boot; an existing Campfire database is used as is.
As in the Rails app, DISABLE_SSL (unset by default) says the site is reached over plain HTTP:
only then are writes without Sec-Fetch-Site accepted, since browsers send that header only to
HTTPS and localhost origins.
Point it at a copy of a Rails install's storage/ with that install's SECRET_KEY_BASE and existing
sessions keep working.
Locally, with Ruby 4.0.7 (via mise):
bundle install
source bin/dev-env # the Rust repo's fixed parity secrets, tmp/seed copy, PORT=3200
bundle exec ruby bin/campfireUnit and integration tests, one file at a time:
mise exec -- ruby -W0 -Ilib -Itest test/messages_test.rbParity and benchmarks use a checkout of
once-campfire-rust (set CAMPFIRE_REF_RUST to
its path for bench/run-all) for its seeds, Rails reference image and harness:
cd ../ref-rust
parity/bin/reference build && parity/bin/seed build
PARITY_CANDIDATE_APP_IMAGE=campfire-ruby:app PARITY_CANDIDATE_IMAGE=campfire-candidate-ruby \
parity/bin/candidate compare --seed default
cd -
bench/run-all --apps reference,go,rust,ruby --reps 3 # needs the four images builtFor quick checks against a running Rails reference, bin/parity /rooms/123 diffs one page with
the Rails CSRF tokens removed.
MIT, like once-campfire. The views and frontend assets
are 37signals' and are used under its license; see MIT-LICENSE.