andurel

Andurel, Space-grade Go framework for humans and agents

---

Everything you and your agent(s) need to build robust and performant applications that will scale to the far-side of the moon.

Andurel is the fullstack framework for the agentic era: one-time generation that writes Go you own, explicit wiring, and an agent-ready CLI. It is Go-native — net/http, no HTTP framework dialect, no dependency-injection container.

Docs: andurel.com · Discord: join here

This README tracks master (head / nightly). It may describe features not yet in the latest semver release. Stable documentation matches go install …@latest at andurel.com/docs.

Platform Support

Andurel supports Linux and macOS on amd64 and arm64. Official releases contain and smoke-test all four combinations.

See release verification for archive installation, checksums, SBOMs, keyless signatures, and provenance.

Why Andurel?

Andurel is built for humans and agents on the same pad:

• Airframe: domains/ (business logic + persistence), services/ (application logic), handlers/ (HTTP), routes/, and middleware/ — all ordinary Go you own
• GNC: Explicit constructor injection in internal/runtime. The dependency graph is readable top-to-bottom; there is no container and no reflection
• Propellant: PostgreSQL with narsilc-generated queries from SQL colocated with the domain that owns it
• Payload: Inertia v3 with React, Vue, or Svelte. One Go backend, official Inertia adapters, optional SSR. Templ survives only for email and the Inertia root document
• Range ops: River jobs, email, and queues on the same stack that serves the request path
• Ground support: Agent-ready CLI with read-only patterns, JSON discovery, and AGENTS.md so machines can operate the project without a second stack
• Live reload: andurel run with Shadowfax for Go, templates, CSS, and Vite (--tools mailpit for sidecars)
• Production build: andurel build compiles Templ, Tailwind CSS, Vite assets, and the Go binary

Humans. One-time generation. The scaffold writes Go and Inertia pages you can read, edit, and ship. After that, the code is yours, laid out in a shape you can navigate.

Agents. andurel patterns show <kind> publishes the reference code and a definition-of-done checklist for every layer. andurel verify proves a change respects the layer boundaries. Machines get the same pad as humans, without inventing a second stack.

Core Technologies

• net/http + pkg/anduin: The single HTTP package — routing, func(ctx) error handlers, middleware, request/response helpers, and the server lifecycle over http.ServeMux
• PostgreSQL + pgx: Database
• narsilc: Typed SQL with caller-owned result structs
• Inertia v3: React / Vue / Svelte + Vite
• templ: Email templates and the Inertia root document only
• River: Background jobs
• OpenTelemetry: Observability
• Tailwind CSS: CSS
• Shadowfax: Dev runner

Install

Match the install channel to the docs you follow.

Latest stable (v2)

go install github.com/mbvlabs/andurel/v2@latest
andurel --version

Specific version

go install github.com/mbvlabs/andurel/v2@v2.0.0
andurel --version

v1 releases stay on the unversioned module path (go install github.com/mbvlabs/andurel@v1.x.y). That path's @latest never jumps to v2.

Nightly (matches master / this README)

Nightly ships as prebuilt binaries on the nightly GitHub release. Do not use go install for nightly; it builds from source without the embedded nightly version metadata.

# Linux amd64 (also available: andurel-darwin-arm64, andurel-darwin-amd64)
curl -L https://github.com/mbvlabs/andurel/releases/download/nightly/andurel-linux-amd64 -o andurel
chmod +x andurel
mv andurel "$(go env GOBIN)/"
andurel --version

Verified release archives (checksums, attestations) are documented in release verification.

Full install guide: andurel.com/docs.

Quick Start

# Default: PostgreSQL + Inertia React + pnpm
andurel new myapp

# Other UI combinations (Inertia adapter + JS package manager)
andurel new myapp --ui vue/bun
andurel new myapp --ui svelte/npm

cd myapp
andurel tool sync
andurel skill install

cp .env.example .env
# Edit .env with your database credentials

andurel db create          # optional: if the local database does not exist yet
andurel db migrate up
andurel run

App: http://localhost:8080

Build a first resource. The generator creates migrations; the agent writes the code from the patterns:

andurel generate migration create_products_table
# Edit the SQL in migrations/, then apply it:
andurel db migrate up

# Read the pattern for each layer, then write the code yourself:
andurel patterns show domain
andurel patterns show handler
andurel patterns show route

andurel sync queries
andurel verify

Explore what the CLI knows:

andurel patterns list
andurel patterns --help
andurel db --help

Project Layout & Options

A new app is ordinary Go you own. Top-level shape:

Path	Role
cmd/app, cmd/queue	Process entry: load env, signal context, single runtime.New / runtime.NewQueue (the App owns its Server)
cmd/migrate	One-shot process: apply pending SQL via storage.RunMigrations
cmd/seeds	One-shot process: run named seed sets
internal/runtime	Composition root: explicit constructors, HTTP server + queue lifecycle
internal/…	Other app support code, such as third-party adapters (for example internal/clients, internal/payment)
config/	App, DB, auth, email, telemetry config
domains/	Business logic + persistence in one flat package; SQL colocated as domains/<entity>.sql
domains/internal/queries/	narsilc output; imported only by domains/**
services/	Application logic / cross-domain orchestration
handlers/, handlers/api/, handlers/auth/	HTTP handlers (func(ctx context.Context) error)
routes/	Route data: names, paths, URL builders
middleware/	App HTTP middleware + cookie-jar wiring
resources/root.templ	Inertia root document (the only page-shaped templ)
resources/js/	Inertia pages, layouts, components, and generated TS helpers
email/	templ email templates and send helpers
queue/	River jobs and workers
migrations/	SQL migrations
seeds/	Seed data
css/ / assets/	Tailwind source and compiled/static assets

Default: Inertia React + pnpm (--ui react/pnpm).

--ui react/pnpm|vue/bun|svelte/npm: Same Go backend; choose the Inertia adapter and JavaScript package manager. Inertia is the only UI; there are no templ/Datastar pages. --api returns JSON responses instead of pages.

Details: directory structure · frontend options.

Core Commands

Command	Purpose
andurel new (n)	Scaffold a project
andurel patterns	Read-only reference patterns for every layer (patterns list, patterns show <kind> --json)
andurel verify	Format, go fix, go vet, the typed layer rules, and generated-code drift; --with-tests also runs tests. Rules: andurel verify --help or the rule table
andurel generate migration	Create a migration file (code-writing generators are gone)
andurel sync	Refresh derived files (queries, email, routes, payloads)
andurel db	Database lifecycle: create, drop, nuke, rebuild, migrate, seed, console
andurel console (c)	Open an interactive database console
andurel run (r)	Dev server with live reload
andurel build	Production build (Templ, CSS, Vite, Go binary)
andurel tool sync	Download pinned project binaries
andurel upgrade	Bring an app forward to a newer Andurel
andurel doctor	Project diagnostics
andurel skill	Show / install the embedded agent skill
andurel inspect	Read-only project shape (handlers, domains, routes, …)
andurel commands	Structured command discovery

Use andurel <command> --help for flags. Full CLI reference: andurel.com/docs/latest/cli.

Agents

The CLI is meant for humans and machines. Prefer discovery over scraping this README:

andurel patterns show domain --json
andurel verify
andurel inspect handlers --json
andurel inspect domains --json
andurel inspect routes --json
andurel commands --json
andurel skill install

andurel patterns never writes files. It prints reference code, the placement rules, and a definition-of-done checklist the agent self-verifies against. Many commands support --dry-run and --json. Agent workflows: andurel.com/docs/latest/agent-workflows.

Contributing

1. Fork and branch
2. Make changes
3. Run just check-fmt, just check-fix, and just vet (or gofmt / go fix / go vet with GOWORK=off)
4. Open a pull request

just recipes and CI set GOWORK=off so the CLI resolves pkg/* from go.mod, matching go install. The workspace file is for local ad-hoc work only.

git clone https://github.com/mbvlabs/andurel
cd andurel
GOWORK=off go mod download
just vet

License

MIT. See LICENSE.

Sites built with Andurel

• DeployCrate: Remote boxes for your agents and teams
• MBV Blog: Personal blog
• Master Golang: Course platform
• Palantir: Open sourced analytics platform (WIP)

Built something cool? Let me know or open a PR.

Author

Created by Morten Vistisen

• Twitter/X
• Mail