intertwingly

DHH opened Rails World by saying what he believes, plainly, and betting his company on it. That's the bar for an opening keynote. He also asked us to be optimistic, and I am, about Rails in particular. Today I open the second day of Deccan Queen on Rails, and I hope I clear the bar he set.

If you're not in the room

The talk opens by asking the room to post in the conference chat, which has been on the second screen since yesterday morning. That chat is Basecamp's Campfire, with the organizers' sign-in, branding and dashboard added in Rails, then compiled to a native binary with no Ruby in it. Everyone at the conference has been its test suite for two days.

You can't join that one, but you can do the second beat from wherever you are:

1. Open rubys.github.io/roundhouse/blog (a phone is fine) and create an article.
2. Open the same URL in a second tab and create another. It appears in both.

That's a Rails app running entirely in your browser. There is no server.

The talk

The slides are at rubys.github.io/dqor-2026, with the speaker notes written to be read: press S, or open ?script for the whole talk as one document. Every number on a slide has its source in the notes.

The argument, compressed:

Rails is a fourth-generation language. FOCUS in 1975 and Active Record in 2026 say the same thing about the same domain: a database, some forms, some reports, some rules. has_many :boosts isn't a call, it's a declaration, the same kind of line a Progress programmer wrote in 1990. Rails put that language inside Ruby so smoothly that nobody had to learn it, or notice they were using one. A framework is a language without a compiler.

The 4GLs didn't die because declarative was wrong. They died because the compilers were the expensive part. Every target was a team, revenue was runtime licenses, and when the platform moved from green screens to Windows to the web, a language with one target and one vendor didn't move with it. SQL is the exception: many vendors, no owner, and competitors who shared the cost of the compiler. It's still here.

This year the compiler got cheap. Roundhouse compiles Rails to ten targets, and it was started by one person with agents. The question John Backus's team faced in 1957 is back: is the compiled program fast enough to be worth it? On Campfire, same machine, same harness:

The hand port is Tobi Lütke's, plain Ruby with no Rails. Ahead on one page, level on one, 2.7× behind on one. The compiled binary, against Campfire as its own Dockerfile runs it, is 14× on the room page in 11× less memory. The raw numbers are public, and so is every test Basecamp wrote, run against the binary: 406 of 406.

Agents build it. The compiler ships it. Aaron Patterson closed Rails World with the compiler's as-if rule: a compiler may change anything you can't observe. Compile the same Rails twice and you get the same C. Ask the same prompt twice and you get two programs. The notation at the top is what you keep; what it compiles to is a separate question.

Rails is bigger than Ruby. SQL in strings, Stimulus in attributes, GraphQL in class bodies, ERB in templates. Each guest language now has its own parser: Prism, Herb, Oxc, graphql-ruby. Each checks its own notation, and nothing checks where they meet. Three of the four example lines on that slide are bugs: one I planted, one in an app generated from a prompt, and one in Campfire itself. Those parts exist; holding them together is the open work.

Who builds it

The 4GL history has a control group. IBM's CSP ran on every IBM platform: many targets, one owner. It never died, and it never became SQL. SQL had many targets and many keepers.

When I started writing this talk there was nothing to put on the slide about keepers. Three weeks ago the first pull request from someone other than me was merged. As of yesterday there are 357, from seventeen people. They brought a Sorbet-typed app, a Rails 8 app with 255 models and controllers, Postgres schemas, Packwerk packages, and an app with 96,000 Ruby files, where roundhouse check went from a projected two hours to seven minutes because someone ran it there and fixed what was slow. They handed constant resolution to Rubydex and rebuilt the CI. One of them made the project stricter: a pull request quieted a diagnostic for a construct the emitted program couldn't run, and the fix was a rule for everyone: a diagnostic you remove is a claim that the emitted program runs.

Around it, things moved on their own. Matz's Spinel compiles the typed Ruby to C, with issues and fixes flowing both ways. IronRuby was revived on .NET and runs the emitted Campfire. And the chat on the second screen was changed by the conference organizers, in Rails, and compiled; nobody touched the C. Vipul A M wrote up how.

Matz keeps the compiler. Basecamp's tests define correct. Seventeen people keep the rest. The bet isn't the compiler; it's the keepers.

Before five o'clock

The talk ends with homework that fits in a conference day:

• Ask your agent to cargo install --locked --git https://github.com/rubys/roundhouse --bin roundhouse and run roundhouse check on your app. What it can't model yet, it says, on the exact line. On one contributor's Rails 8 app, a single missing entry was 359 of 836 errors. Each gap you fix is fixed for everyone.
• No install: the studio, a Rails blog compiled in the browser, with its tests.
• If your app serves GraphQL, send me the graphql: line from check. Counts and reasons, not your schema.
• Start with AGENTS.md. The open issues are plans, not claims.

Why Pune

In the late 1980s India asked to buy a Cray supercomputer, and the answer was no. In 1987 C-DAC was founded, here in Pune, and in 1991 it shipped PARAM 8000. They didn't copy the machine they were refused. They built a different one, together, from parts they could get.

That's the shape of this project too: Prism, Herb, Oxc, Rubydex, Spinel, Basecamp's tests, each kept by someone else, combined. The talk closes with the architect of PARAM, Dr. Vijay Bhatkar: "Go hungry, go crazy and do something that will transform India and the world." Don't stop where I stopped. Don't stop where Rails stops.

The long form

• the thesis, before the talk existed: The Hidden 4GL
• what sits at the top of the drill: Pencils Down, Notation Up
• compile, port again, or maintain the port: As If
• why I care, and the offline requirement that started it: Rust is the answer to the wrong question
• the seams: The Browser Half, Generated Rails, Resolvers Have Types Too
• what a contributor asked for: Keep the Gems

Roundhouse is open source: dual-licensed MIT / Apache-2.0. The slides, notes and benchmarks are public. Issues and discussion welcome.