A CLI that bootstraps production-ready Go apps with hexagonal architecture. Choose your API mode — SSR (templ + HTMX, default), REST (JSON API), or gRPC — then add, update, and remove models without touching boilerplate.

• Go 1.26+
• PostgreSQL (if using --db postgres)
• buf (if using --api grpc, for proto code generation)

go install github.com/esrid/scaffold@latest

Or build from source:

git clone https://github.com/esrid/scaffold
cd scaffold
go build -o scaffold .

# SSR project (default — templ + HTMX + plain CSS)
scaffold init myapp --module github.com/you/myapp --db sqlite
cd myapp && make run

scaffold gen Product name:string! price:float! description:string
# → generates CRUD pages at /products (list, show, create, edit)

# REST JSON API
scaffold init myapp --module github.com/you/myapp --db sqlite --api rest
scaffold gen Product name:string! price:float!
# → generates JSON CRUD at /api/products

# gRPC + REST dual-stack
scaffold init myapp --module github.com/you/myapp --db postgres --api grpc
scaffold gen Order status:string! total:float!
# → generates proto + gRPC handler + REST JSON routes

Bootstrap a complete project from the built-in boilerplate.

scaffold init [dir] --module <path> [--db sqlite|postgres] [--api ssr|rest|grpc]

dir defaults to the last segment of --module. Runs go mod tidy automatically. Refuses to scaffold into a non-empty directory (a lone .git/ or other dotfiles are fine).

Generate or update the full CRUD scaffold for a model. Routes are mounted automatically in app.go.

scaffold gen <Model> [field:type{modifier}!...] [--remove <field>...] [--dry-run] [--table-name <name>] [--no-handler] [--soft-delete] [--unique-together <fields>]

Running gen again on an existing model merges the fields you pass into the stored set: a field name that already exists is updated in place, a new name is added, and fields you don't mention are kept. Passing a subset never drops columns. To drop a field, name it with --remove. Adding/removing fields writes a diff migration; your hand-written files are never overwritten.

name:type              nullable field (Go pointer, e.g. *string)
name:type!             NOT NULL field

# Modifiers (comma form is shell-safe in zsh/bash):
name:type,mod          field with modifier (e.g. email:string,unique)
name:type,mod,mod!     multiple modifiers, NOT NULL

# Array fields (array/arr modifier is shell-safe):
name:type,array        array field (e.g. tags:string,array)
name:type,array!       NOT NULL array field

# Legacy brace & bracket syntax (requires quotes in zsh/bash):
name:type{mod,mod}!    brace-wrapped modifiers
name:[]type!           prefix-bracket arrays

! and nn are equivalent.

Shell-safe vs Legacy Syntax: A modifier list with a comma inside braces ({255,unique}) triggers shell brace expansion in zsh, and brackets ([]) or operators like > can be intercepted by the shell. To avoid quoting, use the comma modifier syntax (email:string,255,unique!) and the ,array suffix (tags:string,array!). If you use the legacy {...} or [] syntax, wrap the entire argument in single quotes: 'email:string{255,unique}!', 'tags:[]string!'.

id, created_at, updated_at are auto-managed — do not declare them (variant spellings like Id or createdAt are rejected too). Field names that are SQL reserved words (order, user, group, to, …) are rejected with a clear error, since the generated SQL does not quote identifiers.

Array fields can be declared using either the shell-safe <type>,array suffix (e.g. tags:string,array!, scores:int,array) or the legacy []<type> prefix (e.g. tags:[]string!, scores:[]int). Valid element types: string, text, int, int64, float, float64, bool (not time or json). Stored as a native array on Postgres and a JSON-encoded TEXT column on SQLite.

Migration safety: adding a NOT NULL field to an existing model emits ALTER TABLE … ADD COLUMN … DEFAULT <zero> ('', 0, FALSE, CURRENT_TIMESTAMP, '[]'/'{}') so the migration applies cleanly on both SQLite and Postgres even with existing rows. Indexes for added columns are created (and dropped before DROP COLUMN) in the same migration.

scaffold gen Product name:string! price:float! sku:string,unique
scaffold gen Article title:string! body:string views:int
scaffold gen Order status:string,default=pending,nn
scaffold gen User username:string,92! email:string,255,unique!
scaffold gen Post user_id:string,fk=users,cascade,index! title:string!
scaffold gen Event payload:json! metadata:json
scaffold gen Post title:string! tags:string,array! scores:int,array  # shell-safe array fields (TEXT[] on postgres, JSON TEXT on sqlite)
scaffold gen Product stock:int                                      # add stock to an existing model (name, price kept)
scaffold gen Product --remove stock                                 # drop the stock column
scaffold gen Product name:string! price:float! --dry-run
scaffold gen Person name:string! --table-name people

Remove all scaffold files for a model and create a DROP TABLE migration.

scaffold destroy <Model> [--keep-custom] [--force]

Prompts for confirmation. By default, it deletes both generated and hand-written files for the model, but automatically creates a backup of any custom hand-written files in .scaffold/backups/<timestamp>/ before deleting.

myapp/
├── main.go
├── Makefile                           # make run / make build
├── .env.example
├── .scaffold/models.json              # manifest
├── internal/
│   ├── app/
│   │   ├── app.go                     # loads templates, mounts routes
│   │   ├── config.go
│   │   └── registry.go                # auto-regenerated
│   ├── core/
│   │   ├── domain/{model}.go          # struct + Validate()
│   │   ├── ports/{model}.go           # interfaces
│   │   └── services/
│   │       ├── {model}_service_gen.go # CRUD delegation (regenerated)
│   │       └── {model}_service.go     # your logic (never touched)
│   └── adapters/
│       ├── http/
│       │   ├── {model}_handler_gen.go # SSR handler + bindForm (regenerated)
│       │   ├── {model}_handler.go     # your extensions (never touched)
│       │   └── middleware.go
│       └── store/
│           ├── {model}_store_gen.go
│           └── {model}_store.go
└── web/
    ├── static/
    │   └── app.css                        # plain CSS stylesheet (served at /static/)
    ├── static.go                          # //go:embed for static assets
    └── views/
        ├── layout.templ                   # shared page layout component
        ├── home.templ
        ├── helpers.go                     # display/truthy template helpers
        └── {model}.templ                  # List/Form/Show components (write-once — yours)

templ compiles .templ files to Go. Run make generate (or templ generate) after scaffold gen and before building.

Same as SSR, except:

• internal/adapters/http/crud_handler.go — generic CRUDHandler[T] (no per-model handler)
• web/src/ + web/dist/ — TypeScript/esbuild frontend scaffold instead of templates
• Routes: GET /api/{plural}, POST /api/{plural}, PUT /api/{plural}/{id}, etc.
• GET /api/{plural} returns newest-first and accepts ?limit= (default 20, max 100) and ?offset=

Adds on top of REST:

• internal/adapters/grpc/pb/{model}.proto
• internal/adapters/grpc/{model}_handler_gen.go
• internal/adapters/grpc/shared.go — error translation (written once)
• buf.yaml + buf.gen.yaml — proto code generation config

Run make proto after scaffold gen to compile .proto → Go pb package.

SSR and gRPC modes:

make run     # go run main.go
make build   # go build -o bin/server
make proto   # buf generate --path internal/adapters/grpc/pb  (gRPC only)

REST mode:

make run     # build TypeScript + go run
make build   # build TypeScript + go build
make build-fe  # esbuild TypeScript + CSS only
make proto   # buf generate --path internal/adapters/grpc/pb  (gRPC only)

internal/core/domain/{model}.go — field validation:

func (p Product) Validate() error {
    errs := domain.ValidationError{Entity: "Product", Errors: map[string]string{}}
    if p.Price <= 0 {
        errs.Errors["price"] = "must be greater than zero"
    }
    if len(errs.Errors) > 0 {
        return &errs
    }
    return nil
}

internal/adapters/store/{model}_store.go — custom SQL queries:

For both Postgres (pgx) and SQLite (database/sql via adapted helpers), you can use struct-mapping helpers like CollectRows and RowToStructByName to map query results without writing manual scanner code:

func (s *ProductStore) FindBySKU(ctx context.Context, sku string) (*domain.Product, error) {
	// Example using SQLite adapted helpers:
	rows, err := s.db.QueryContext(ctx, "SELECT id, name, price, active, created_at, updated_at FROM products WHERE sku = ?", sku)
	if err != nil {
		return nil, err
	}
	return store.CollectOneRow(rows, store.RowToAddrOfStructByName[domain.Product])
}

internal/core/services/{model}_service.go — business logic:

func (s *ProductService) Publish(ctx context.Context, id string) error {
    // your logic here
}

SSR: internal/adapters/http/{model}_handler.go — extra routes:

func (h *ProductHandler) RegisterExtraRoutes(r chi.Router) {
    r.Get("/featured", h.Featured)
}

# Fast unit tests (no network, no Docker)
go test ./... -short

# Compilation tests (downloads deps, ~10s)
go test ./internal/generator/boilerplate/...

# Full integration tests with Postgres container (requires Docker)
go test ./internal/generator/boilerplate/... -tags integration