.NET has every world-class ingredient — Kestrel, among the fastest web servers alive; EF Core; SignalR; Hangfire; Native AOT — and in twenty years it never produced a Rails: an omakase, convention-over-configuration framework that decides for you. Chord is that framework, written in and for G# — Go, Kotlin, and Swift ergonomics on the CLR, real and public at v0.3, young enough to be unburdened by history or by anyone's expectations. One CLI. One binary. One Postgres. The best ingredients in the industry, finally sounded together — and every decision you didn't have to make is the product.
.NET's problem was never engineering. It was culture. Enterprise C# demands explicit dependency injection, configuration ceremony, Clean Architecture rituals — every team re-decides forty questions before hello-world, and calls the re-deciding rigor. Meanwhile Rails and Laravel proved, for two decades and across two ecosystems, that omakase wins for product teams. The stack was never the obstacle. Permission was:
DI container shape, project layout, ORM posture, auth story, front-end strategy, mediator-or-not, test topology. Every one is documented, none is decided. The framework is world-class at everything except having an opinion.
Convention-driven frameworks have been tried in .NET and culturally vetoed — “too much magic,” “not enterprise-ready,” “where's the interface?” The culture forbids exactly what Rails proved. The parts stayed parts because nobody was allowed to plate them.
Laravel is taste layered over Symfony components — the engineering was already done; the product was the deciding. Chord makes the same move over a far stronger substrate: Kestrel, EF Core, SignalR, Hangfire are the Symfony beneath it.
Nobody has expectations of G# yet. No style guide, no architecture priesthood, no “that's not how we do it here.” The language is real — a compiler, a spec, a tour — but its culture hasn't formed. A G# framework gets to decide for you on day one, and day one is still in progress: the conventions can land before the culture that would veto them exists.
Chord's covenant is Rails': names carry meaning, structure is derived, and the framework fills every silence with a default. The difference is what's underneath — not MRI, but the CLR with Native AOT; not WEBrick's descendants, but Kestrel. The slow-framework tax that omakase always paid is simply not owed here.
chord g scaffold deal
title:string amount:money emits the model, the migration, the handlers, the
views, and the tests — as plain G# in your tree. Chord has no
method_missing; its magic is legible, diffable, and yours to edit.
A file at app/handlers/deals.gs
with a func create is
POST /deals. Handlers take a data class as their params object — one typed shape for
the request — and if let /
guard let guard the
null-heavy edge where web input actually lives.
Server-driven UI over SignalR, Hotwire-shaped: the server renders HTML, the wire carries HTML, a small client morphs the DOM. No client build step, no hydration, no multi-megabyte payload. Explicitly not Blazor — the browser gets documents, not a runtime.
chord deploy:
Native AOT compile, one static binary a few megabytes large, sub-100ms cold start,
Postgres the only thing standing next to it. Rails DX at write time; a Go-shaped
artifact at ship time.
“Convention over configuration” hides what a convention actually is: a decision, made once, by someone else, so ten thousand teams don't each pay to make it again. Chord keeps its decisions in a public register — numbered, argued, and amendable by RFC. Each entry records what was chosen, what was rejected, and what evidence would reopen it. Here are the first twelve.
func handlers, data
classes for params and models, if let
over nullable input, scope
blocks for request-scoped structured concurrency. Go's directness, Swift's nullable
discipline, the whole BCL a dot away.
Deal.where(...) reads
like ActiveRecord and compiles like LINQ. Migrations are first-class CLI citizens —
generated with the scaffold, run with the deploy.
The canonical exchange: you describe a resource once, on the command line, and the
framework answers with an application. Everything on the left is plain G# — the
shipped tour's G#: Go-style parameters, guard let
from ADR-0071, a primary-constructor data class — nothing invented but the framework's
own types; everything on the right is the whole distance from name to production.
package App.Handlers import Chord.Web data class DealForm(title string?, amount money?) func create(form DealForm) Response { guard let title = form.title else { return web.invalid("title is required") } let deal = Deal.insert(title, form.amount ?? 0) return turbo.stream(deal) // html over the wire }
$ chord g scaffold deal title:string amount:money create app/models/deal.gs ✓ create db/migrate/0042_deals.gs ✓ create app/handlers/deals.gs ✓ create app/views/deals/index.gs ✓ create app/views/deals/form.gs ✓ create tests/deals_test.gs ✓ $ chord deploy gsc ✓ 0 errors · 640 ms aot ✓ one static binary · 18 MB migrate ✓ 0042_deals · 12 ms boot ✓ 40 ms cold start → live one binary, one postgres, nothing else
The generators emit G# you own. Chord is not magic — it is defaults: eject any file, rewrite any handler, replace any view, and the framework keeps working, because the framework was only ever the thing that wrote the first draft. Convention is where you start, never where you're trapped.
No model on earth has trained on G#, and chord's answer is not to wait for the crawlers. It is to notice what omakase actually is: convention over configuration is context compression. A framework with one blessed way to do each thing is the most agent-legible framework possible — there is nothing to infer, no forty-architecture guessing game about which shape this particular repo chose. Rails' conventions were designed for human onboarding. Chord's are designed for a context window.
In an ASP.NET Core repo, an agent's first job is archaeology — which DI shape, which mediator, whose Clean Architecture. In a chord app the answer is always the register's answer, so the model spends its intelligence on your product instead of your wiring.
chord g emits the
same shape every time, so one worked scaffold teaches the pattern for every
resource that follows. An agent predicts the generator's output, diffs its
expectation against reality, and learns the framework from the delta.
The decision register doubles as the model's briefing: what was chosen, what was rejected, and what evidence would reopen it — the exact document an agent needs to stop proposing alternatives that were already ruled out on purpose.
The tour, the conventions, the register, one worked scaffold — emitted as a single model-ready bundle. Fluency arrives in-context, in seconds, for whatever model shows up next quarter. No training run required, no waiting for a corpus to accrete.
$ chord ctx tour ✓ g# v0.3 · the shipped language tour register ✓ forty decisions · choices and rejections scaffold ✓ one worked example · deal, end to end conventions ✓ names, routes, trees · the covenant → chord.ctx.md · 41k tokens · paste into any model
Rails runs on Ruby metaprogramming; G# gives chord attributes, reflection, and
source generation. The answer is generated-code-you-can-read — which is also
generated code you can drift from. When conventions evolve, your ejected files
don't. Regeneration discipline is the tax, and chord pays it with a named tool,
not with hope: chord evolve
re-scaffolds against your edits three-way-merge style, shows the diff, and never
overwrites a line you changed without asking.
G# is real and shipping — a compiler (gsc), an MSBuild SDK, a VS Code extension, a language server, a full written spec, dozens of releases. It is also one Microsoft engineer's personal project at v0.3: not an official product, not a committee, not a guarantee. Doubled risk, stated plainly. The mitigation: chord's guts are ordinary C# assemblies on the ordinary CLR; only the surface a developer touches is G#. If the language stalls, the framework limps; it doesn't die.
Every model on earth writes C# and Rails fluently; none has ever seen G#. cs2gs, tour-faithful syntax, and a thin, conventional surface shrink what a model must learn — but day-one agent fluency is streng's argument, and chord loses it. We are betting that a small, regular language is quickly learned. Betting, not knowing — the sight-reading section above is that bet, made specific.
The .NET community will ask “why not Blazor” forever, and it deserves an answer every time. HTML-over-the-wire is a philosophical stance — documents over runtimes, server truth over client state — defended, not assumed. Some apps genuinely want Blazor. Chord is not for them, and says so.
Rails' conventions weren't invented; they were extracted from Basecamp. Chord's conventions, today, are extracted from nothing — they are hypotheses with good posture. Until real applications grind them down, they're guesses wearing confidence — which is exactly why the decision register exists, and why every entry in it is amendable by RFC rather than carved in the framework.
One Postgres, HTML over the wire, jobs in the box — every default excludes someone. The team with Cosmos DB, a React fleet, and a Kafka spine should use ASP.NET Core straight, and chord's docs say so on page one. An omakase that claims to suit everyone is a menu.
The pitch, in one sentence: chord is the forty decisions .NET never made, made — Rails' covenant on Kestrel's engine, written in a language young enough to say yes, shipping as one readable codebase, one static binary, and one Postgres.