early · v0.10.0

Full-stack Go, with agents at the table.

GoFastr is a Go full-stack framework. You wire your app in Go like you'd wire net/http — declare your domain and get screens, REST endpoints, MCP tools, an OpenAPI spec, SQL migrations, and a typed query builder, all on disk in plain Go you can read and step through.

The same surface is wired for AI agents from day one. Every entity ships with an MCP tool surface; Kiln (experimental) is a separate binary that lets an agent author your app in chat while you watch the code change.

Get startedRead the docs
$ go install github.com/DonaldMurillo/gofastr/cmd/gofastr@latest
blog/main.go
30 lines
package main​import (  "github.com/DonaldMurillo/gofastr/framework"  "github.com/DonaldMurillo/gofastr/battery/auth"  f "github.com/DonaldMurillo/gofastr/framework/field")​func main() {  app := framework.New(framework.Config{    Name: "blog",    DB:   framework.SQLite("./blog.db"),  })​  app.Use(auth.Memory())  // swap for auth.Postgres() in prod​  // One call. Generates SQL, REST, MCP, OpenAPI, Go types.  app.Entity("posts", framework.Entity{    Fields: framework.Fields{      "title":  f.String().Required(),      "slug":   f.Slug().From("title"),      "body":   f.Markdown(),      "status": f.Enum("draft", "published").Default("draft"),    },    Timestamps: true,    Expose:     framework.Expose{REST: true, MCP: true},  })​  app.Serve(":8080")}

One file. A whole app — screens included.

A gofastr.yml blueprint declares your entities and the screens that render them — list tables, forms, detail pages, charts, a marketing site. gofastr generate writes owned Go you read and edit. Not a CRUD scaffold.

gofastr.yml
29 lines
app:  name: Meridian​entities:  - name: customers    fields:      - name: name        type: string        required: true      - name: plan        type: enum        values: [free, pro, enterprise]      - name: mrr        type: decimal      - name: status        type: enum        values: [active, churned]​screens:  - name: customers    route: /customers    body:      - kind: page_header        props:          title: Customers      - kind: entity_list        entity: customers        create: true        fields: [name, plan, mrr, status]
$ gofastr generate --from=gofastr.yml
→ wrote main.go, entities/register.go, blueprint/screens.go → 1 entity · 3 screens · migrations/0001_init.up.sql → next: go run .

gofastr.yml is the on-ramp, not a runtime lock-in — after generating, the Go is canonical and you can delete it. → See the Meridian blueprint

meridian.local/customers

Customers

+ New customer
NamePlanMRRStatus
Acme Corppro$1,240active
Globexenterprise$8,900active
Initechfree$0churned
Umbrellapro$2,150active

/customers — generated, server-rendered, owned Go you can edit.

One entity call generates the surfaces your app and your agent both need.

Output lands on disk under gen/ as regular Go and SQL. There is no reflection at runtime; if something the framework does feels like magic, open the generated file and read it.

01
SQL table + migration
Versioned, ordered, reversible. up/down SQL emitted as plain files.
migrations/
02
REST endpoints
List, get, create, update, delete, batch. Cursor + offset pagination. Filter DSL on the query string.
GET POST /posts
03
MCP tool surface
posts_list, posts_get, posts_create, posts_update, posts_delete. Same auth + access rules as REST.
core/mcp
04
OpenAPI 3 spec
Schema, parameters, responses. Swagger UI auto-mounted at /api/docs.
/openapi.json
05
Typed Go model + query builder
posts.Query(ctx).Where(posts.Status.Eq("published")).List(20). No reflection, no interface{}.
gen/entities/posts.go
06
Lifecycle hook slots
BeforeCreate, AfterUpdate, BeforeDelete — your code runs in the parent transaction.
framework/hook
07
Admin UI (opt-in)
A listing + form per entity. Off by default. Add Admin: true to enable.
/admin/posts

Two layers. Twelve batteries. Drop down whenever.

core/ is stdlib-only Go primitives. framework/ is the opinionated entity layer composed on top. If the framework is in your way, you drop down to core — the imports change, your code doesn't.

The floor

core/

Twelve primitives. Stdlib only. Works standalone.

router handler middleware
query mcp schema migrate
render stream openapi
static upload

The frame

framework/

The opinionated entity system, composed on top of core. ~25 packages.

entity crud filter dsl
hook migrate tenant access
file cron event log
ui …and more

Pluggable

battery/

One interface per concern. In-memory dev driver, production driver behind the same shape. Swap without forking.

auth cache email embed
notify queue search storage
webhook log admin print

UI runtime

core-ui/

Server-driven. Signals + HTML primitives + islands + SSE. ~10 KB gz vanilla JS. No React.

signal html island stream
accordion tabs modal
drawer popover toast

The agent's view of your app is the same as yours.

Same database, same routes, same files on disk. The MCP tool surface is just the REST surface in a different shape. Destructive changes require an approved plan; the agent cannot drop your tables without you clicking approve.

framework

Every entity is an MCP surface

For each entity you declare, the framework registers MCP tools that map 1:1 to your REST surface. An agent connects to /mcp and calls them with the same auth context a human would have over HTTP.

  • posts_list — same access rules as GET /posts
  • posts_create — same validators, same hooks
  • posts_update, posts_delete — same audit log
  • Scope per tool with Expose.MCP.Tools: []string{"list","get"}
kiln · experimental (separate binary)

An agent that authors your app

Kiln mounts a floating chat panel on the running app. The agent calls a typed tool surface (add_entity, add_field, propose_plan, …). Plans render as diffs you approve. The journal is committable.

$ kiln serve --agent claude-code
→ panel floats on http://localhost:8765 → MCP server live at /mcp → journal in .kiln/journal → ready · waiting for the agent.

Seven reference apps. Each runs in one command.

Clone the one that looks like your problem; swap the entity declarations.

examples/meridian

Meridian — SaaS console

The flagship. A billing console + marketing site + auth + admin, generated from one gofastr.yml with writable add/edit/delete screens.

cd examples/meridian && go run .examples/blog

Go-declared blog

Users, posts, comments. Three entities. The smallest end-to-end example — start here.

cd examples/blog && go run .examples/site

This site

The site you're reading — every framework/ui + core-ui primitive showcased one page each, plus the docs, SEO, wizard, and print demos.

cd examples/site && go run .examples/api-tour

API tour

Every REST endpoint as a chapter. Each chapter has a live curl example you run from the page.

cd examples/api-tour && go run .examples/embed-demo

A markdown corpus indexed locally via battery/embed. No external API key, ~180 LoC total.

cd examples/embed-demo && go run .examples/spa

Vue + GoFastr API

For teams who already have a client app. Shows the framework is happy to just be your typed API.

cd examples/spa && go run .examples/static-site

Static-site mode

Same renderer, no server. gofastr build emits a CDN-friendly bundle.

cd examples/static-site && gofastr build
early · v0.10.0

Built in public. Use it to learn, not to ship.

APIs change between commits. core-ui/ is the active research frontier. The journal is open; rough edges are visible by design. We say no to things — you should know what we're saying no to.

honest about
Breaking changes between commits — see the journal
Half-built batteries, marked WIP in source
No upgrade guide between minor versions yet
will not do
Reflection-driven magic that hides what's running
Pricing pages, logo clouds, testimonial carousels
Lock-in — drop down to core/ any time
roadmap, in order
Lock framework/entity ABIQ3 '26
Land core-ui 1.0Q4 '26
First version we'd suggest shipping2027