Docs · v0.66.0
Read by what you're trying to do.
The docs are grouped by intent. Pick the one that matches the question you're holding.
95 docs · 8 intents
00
Start here
What GoFastr is, how a project is laid out, and a map of every feature: the newcomer narrative before the per-feature references.
Backend capability map
One row per job: scope rows to a user, add auth, run background work: with the symbols to compose and a command that proves it.
Overview
What the framework is, the two layers, and a linked map of every capability.
The gofastr CLI
Every subcommand mapped to its doc: init, dev, migrate, generate, audit, upgrade.
Tutorial: blueprint app
The optional blueprint scaffolder end to end: one gofastr.yml becomes a UI + API you own, in about twenty minutes.
Project structure
Start flat; grow into internal/<domain> as real boundaries appear. Structure follows the app.
Comparison
Where GoFastr sits relative to other full-stack frameworks.
Upgrading
Move an app (and the CLI) to a newer release: plus gofastr upgrade, the guided helper.
API stability
Compatibility windows, deprecation rules, and the public v1 promise.
Recommended pathOverview→Tutorial: blueprint app→Project structure
01
Modeling your domain
Declare entities, fields, relations. The framework generates schema, CRUD, validators, and code.
Entity declarations
JSON or Go: both produce the same tables, routes, and tools.
Filter DSL
?status=published&views_gte=10&sort=-created_at parses to a typed Where.
Cursor pagination
Keyset by EntityConfig.CursorField. Opt in by sending ?cursor=.
Eager loading
?include=author.profile flattens the N+1.
Hooks & transactions
BeforeCreate / AfterUpdate hooks share the parent tx.
Migrations
Versioned, ordered, reversible: versus the auto-migrate dev mode.
Multi-tenant scope
tenant_id column + automatic filter from request context.
Code generation
What lands on disk under gen/: and how to read it.
Ship your API as a CLI
gofastr generate cli: a branded terminal client for your customers, with scoped API-token auth.
Ship your API as SDKs
gofastr generate sdk: a downloadable Go module + JS/TS client, hosted by the app behind a live docs site.
Recommended pathEntity declarations→Filter DSL→Cursor pagination
02
Serving HTTP
Routes, middleware, sessions, auth, idempotency, security headers: everything between the wire and your handler.
Access control
RolePolicy, RequirePermission, custom Policy implementations.
Auth
Login, OAuth, magic-link, 2FA, password reset: each a plugin.
Idempotency
An Idempotency-Key header replays mutations safely.
API prefix & versioning
Mount the API under a prefix and evolve it across versions.
Cache
Memoize expensive reads with a pluggable backend and TTLs.
Security defaults
CSP, CSRF, rate limit, headers: all on by default.
Rate limiting
Throttle any route with the sliding-window limiter the auth flows use.
Health checks
/healthz + /readyz with plugin checks.
Webhooks
Signed outbound delivery with retry-with-backoff.
Notifications
Multi-channel fan-out with per-channel templates.
Batch endpoints
Create / update / delete many rows in one request.
Plugins
The lifecycle every battery and feature plugs into.
Modules
Runtime enable/disable for batteries with manifests.
Recommended pathAuth→Access control→Security defaults
03
Building UI
Start from a product job, then choose the state boundary, server-rendered islands, primitives, runtime, and theme.
UI capability map
Live dashboards, optimistic boards, master/detail, reactive state, static export, and SPA integration: mapped to proof and delivery semantics.
Live dashboards
Compose SSE island push, store.Computed, a bounded feed, and the connection-health banner: and the boundaries that decide when each is the right shape.
Getting started (UI)
The path: scaffold → theme → screen → custom component.
Composition recipes
Choose a page shape before composing framework-owned primitives.
Wiring UI into an app
framework.App + core-ui app + uihost, end to end in one annotated main.go.
Screens and layouts
Layout chains: nesting with ScreenGroup, per-layer markers, deepest-shared-layer swaps, prefetch, scroll restore.
New components
The minimal-register + SSR-inline + hydrate contract.
Theming
The token catalog, dark mode, ui.Themed, and the --ui-* override vars.
Widget builder
Build islands that hydrate against a registered handler.
Forms
Server-validated forms with island-swapped error states.
Image pipeline
Pure-Go resize + WebP lossless encode.
Runtime modules
Carved per-feature so pages without X don't ship X's JS.
Print documents
Server-rendered print-friendly documents + PDF.
Dev livereload
SSE-driven reload while you edit: zero config.
Static-site export
Render the whole app to static HTML + assets for apex or project-path hosting.
PWA
uihost.WithPWA: installable manifest, versioned offline shell, and a safe service worker.
SEO
Meta tags, Open Graph, JSON-LD, sitemap, robots, and the one-image icon surface.
Accessibility
Built-in ARIA guarantees, the guided audit command, and the build gate.
Strict mode
WithStrict: missing SEO and missing per-screen axe tests fail boot instead of shipping.
Reactivity model
The four-rung ladder: client signals, RPC, polling, SSE push: and the stateless-interactive-layer contract.
Interactive patterns
The data-fui-* vocabulary: RPC islands, signals, open-widget, optimistic actions, polling.
Optimistic UI
The mutation lifecycle, rollback vs authoritative refresh, and seven composed recipes: toggle, inline edit, create, delete, kanban, group mutex, and slow/failure.
Pane host
Master-detail split-pane layout that collapses to an overlay drawer on narrow screens.
Embeddable surfaces
Hand a screen to a website you don't control: single-use handshake nonce, exact origin allowlist, a frame runtime with no SPA navigation.
Plugin platform
Host third-party JS plugins in a sandboxed opaque-origin iframe with a capability-gated postMessage protocol.
Process modules
Third-party modules as isolated child processes: crash/upgrade/revoke without touching the host, capability-brokered data, sandbox trust tiers.
Runtime contract
The SSR/hydration/island/SSE model and the full data-fui-* attribute reference.
Signal store
Typed, namespaced client state that fans out to many consumers from one declaration.
Background compute
Registered Web Workers + WASM modules, content-addressed and CSP-safe, off the main thread.
Recommended pathUI capability map→Getting started (UI)→Composition recipes
04
Persisting & migrating
SQLite and Postgres, dialect-aware, with the migration CLI and per-test isolation.
Audit log
WithAuditLog writes a row for every Create/Update/Delete.
Data export & import
Dump every entity's rows to a portable archive and restore it with validation.
Presence
Live 'who's here' rosters over the SSE lane: server-derived identity, single-replica.
Isolation
Linked git worktrees get isolated local DBs.
Testkit
Public helpers for host apps that need an isolated Postgres in integration tests.
Factories
Rails-style fixtures for tests.
Full-text search
Find records containing a term, dialect-aware.
Uploads
File + image fields with pluggable storage backends.
Storage backends
Local-filesystem and S3-compatible backends behind one Storage interface.
Email
SMTP sending, a dev log sender, and template rendering.
Env / .env
core/dotenv auto-loaded by NewApp.
Core packages
A map of the exported core/* packages and when to reach for each directly.
The SQLite driver GoFastr ships
modernc.org/sqlite registered as sqlite3, the three DSN defaults every connection gets, and why an in-memory database needs one connection.
Recommended pathAudit log→Isolation→Factories
05
Working with agents
MCP tools, Kiln build mode (experimental), agent permissions, plan-gated destructive ops.
Agent-readiness
Discovery surface scanners (isitagentready.com) look for: llms.txt, A2A card, MCP/OAuth well-knowns, markdown negotiation.
Contracts
gofastr verify: one pipeline of rules with IDs, reasons, and fixes, plus semantic coverage and machine-readable diagnostics.
Kiln overview
Experimental: the agent-driven build-mode binary.
Semantic search
Local semantic search via brute-force cosine: no API key.
Audit deps
Detect packages an agent shouldn't import.
Blueprints
Reusable bundles of entities + screens an agent can apply.
Recommended pathAgent-readiness→Contracts→Kiln overview→Semantic search→Agent notes
06
Operations
Run it in production. Logging, metrics, feature flags, env, i18n.
Logging
Structured JSON logs with MCP query tools.
Observability
Metrics and tracing for the hot paths.
Deployment
Ship it: build, configure, and run GoFastr in production.
Backups and restore
Database backup commands for SQLite and Postgres, and how to prove a restore works.
First-run setup
A setup wizard (or headless env bootstrap) gates the app until first-boot state exists.
Horizontal scaling
What's process-local by default and the replica-safe alternative for each.
Job queue
Durable background jobs via battery/queue.
Feature flags
Rollout percentage, allow lists, env evaluator.
i18n
JSON catalogs, plurals, Accept-Language negotiation.
Cron
Scheduled jobs with retry + jitter.
Events
In-process pub/sub for decoupled side effects.
Admin UI
An opt-in listing + form per entity.
Recommended pathLogging→Feature flags→i18n
07
Reference & internals
Performance numbers and the deeper design + tooling docs: surfaced so nothing is hidden.
Benchmarks
What's measured, how, and the methodology behind the numbers.
Performance results
Latest throughput / latency results across the hot paths.
Harness architecture
The AI coding-harness design (contributor/internal reference).
Harness E2E testing
How the harness drives end-to-end browser tests.
Recommended pathBenchmarks→Performance results
∑
Every doc · A–Z
The complete embedded reference: every page, alphabetical, featured or not. It is the same content as `gofastr docs`.
Access control
Accessibility — built-in guarantees, the audit command, the build gate
Admin UI
Agent-readiness
API prefix & versioning
Ship your API as a CLI
Auditing init-time global registrations
Audit log
Authentication
Backend capability map
Backups and restore
Batch endpoints
Benchmarks
Blueprints
Cache
The gofastr CLI
Codegen
Comparison — where GoFastr sits
Background compute with Web Workers and WebAssembly
Contracts — `gofastr verify`
Core packages
Cron / scheduled jobs
Cursor pagination
Data export & import
Deployment
Dev-mode livereload
.env files
Email
Embeddable surfaces
Entity Declarations
Entity events & SSE
Factories / fixtures
Feature flags
First-run setup
Form Module
GoFastr harness architecture
Harness end-to-end testing
Health and readiness
Hooks & transactions
Internationalization
Idempotency keys
Image pipeline
Includes & eager loading
Interactive patterns
Worktree isolation
Kiln — agent-driven build mode
Screens, layouts, and layout chains
Live dashboards
Server logs (`battery/log`)
Migrations
Modules
Multi-tenant scoping
Unified notifications
Observability (metrics & tracing)
Optimistic UI — mutations, rollback, and reconciliation
Overview
Pane-host — primary pane + openable side panes
Performance results — historical snapshot, 2026-07-18 (v0.26.0)
Heavy-JS plugin platform (`framework/pluginhost`)
Plugins
Live Presence
Printable documents
Process modules
Project structure
PWA — installable app + offline shell
Query DSL
Job queue (`battery/queue`)
Rate limiting
Reactivity model
Runtime contract — SSR, hydration, islands, and the `data-fui-*` reference
Runtime JS minification
Horizontal scaling
Ship your API as SDKs
Search
Security defaults
Semantic search
SEO — meta tags, Open Graph, JSON-LD, sitemap, robots, icons
Signal store (shared client state)
The SQLite driver GoFastr ships
API stability and deprecation policy
Static-site export
Storage
Strict mode — launch hygiene as boot failures
Testkit — isolated Postgres helpers for integration tests
Theming
Tutorial: one blueprint → UI + API you own
UI capability map
UI composition recipes
UI getting started
UI components — index
UI wiring — adding the UI system to a framework.App
Upgrading — move an app to a newer GoFastr release
File uploads
Outbound webhooks
Widgets — `core-ui/widget`