Grit

Describe your data. Get the whole app.
Describe a resource. Get the Go model, the API, the migrations, the TypeScript types, the React hooks and the admin screen. Auth, jobs, storage and deploy are already there.

Live demo · Install · 5-minute tutorial · Build with AI · Docs · Discussions · Community

Install

curl -fsSL https://gritframework.dev/install.sh | sh        # macOS, Linux, Git Bash

irm https://gritframework.dev/install.ps1 | iex             # Windows PowerShell

No Go toolchain needed. grit version to check, grit update to self-update.

go install github.com/MUKE-coder/grit/v3/cmd/grit@latest    # with a Go toolchain
GRIT_VERSION=v3.320.0 curl -fsSL https://gritframework.dev/install.sh | sh   # pin a release

Sixty seconds

grit new myapp --triple --next   # Web + Admin + API
cd myapp
docker compose up -d             # Postgres, Redis, MinIO, Mailhog
pnpm install
grit start

Open http://localhost:3000, register, and you are logged into an application that already has authentication, two-factor, an admin panel, a database browser and API docs.

Or skip the install: demo.gritframework.dev is a real application built with Grit, running, and its whole source is in demo/ in this repository. Multi-branch inventory, a point of sale, unit sales, loan schedules and mobile-money collections, with the admin panel, the audit log and the job dashboard you get in every project.

Cloned a teammate's project? grit env writes your .env from .env.example and generates every secret, so you skip the half hour of hand-making keys.

No Docker, or low on RAM? Grit runs against free cloud tiers (Neon, Upstash, Cloudflare R2, Resend) with no local containers. Installing without Docker.

One command, nine files, zero wiring

grit generate resource Invoice --fields "number:string:auto:INV,total:money,status:select:draft|sent|paid,customer:belongs_to:Customer,due:date"

flowchart LR
    CMD["grit generate resource Invoice"] --> API
    CMD --> SHARED
    CMD --> UI

    subgraph API["apps/api · Go"]
        M["models/invoice.go<br/>GORM model + hooks"]
        S["services/invoice.go<br/>business logic"]
        H["handlers/invoice.go<br/>thin HTTP layer"]
        R["routes<br/>injected, not hand-wired"]
    end

    subgraph SHARED["packages/shared"]
        Z["schemas/invoice.ts<br/>Zod"]
        T["types/invoice.ts<br/>TypeScript"]
    end

    subgraph UI["apps/admin + apps/web"]
        Q["hooks/use-invoices.ts<br/>React Query"]
        P["resources/invoices<br/>table · form · filters"]
    end

Run grit migrate and the admin has a working invoices screen: stat cards, search, date filters, sortable columns, bulk actions, CSV import and export. The customer picker is searchable. The total is money, not a float. The invoice number fills itself in from a gap-free counter (INV-202609-0001). The API validates against the same Zod schema as the form.

There is no runtime magic. No reflection, no hidden proxies, no framework internals you cannot read. Grit writes a normal Go API and a normal Next.js app into your repository. You read the files, change them, ship them. Stop using the CLI tomorrow and the project still builds.

It is real code, and it holds up: grit seed Contact --count 1000000 fills a table with a million realistic rows in about fifty seconds on Postgres, batched and resumable, and the admin still pages through them instantly.

What ships in every project

Auth UI. Sign in, register, reset, verify, 2FA.	Forms. Built from your field definitions, pickers included.
Roles and permissions. Per resource, from one command.	Line items and money. Integer minor units, never floats.
Jobs, cron, mail. With a dashboard, not just a queue.	API docs. Generated from the routes, always current.
Every resource gets this. Sort, filter, search, page, import, export.	One account screen. Password, 2FA, passkeys, sign-in links, devices.

One API, every client: web · admin · mobile (Expo) · desktop (Wails)

Why developers pick Grit

Grit is to Go + React what Laravel + Filament is to PHP: Rails' convention over configuration, Django's batteries and a Filament-style resource admin, on a backend that compiles to one static binary.

Build something real in five minutes

A support desk with customers, tickets, a filterable table, a form with a customer picker, a REST API and fifty rows of realistic data.

1. Scaffold and start the infrastructure.

grit new helpdesk --triple --next
cd helpdesk
docker compose up -d
pnpm install

2. Model the domain. One command per noun. The field types decide the database column, the validation, the TypeScript type and the admin input, all at once.

(Issue rather than Ticket: Grit ships a support desk, so Ticket is one of about forty names the generator reserves. It tells you, and names the feature that holds it, rather than writing over it.)

grit generate resource Customer --fields "name:string,email:email,company:string:optional"

grit generate resource Issue --fields "subject:string,body:richtext,priority:select:low=Low|normal=Normal|high=High,status:select:open=Open|closed=Closed,customer:belongs_to:Customer" --seed --faker --count 50

Each of those writes nine files and injects the wiring: a GORM model, a service, a handler, the routes, a Zod schema shared by every frontend, TypeScript types, React Query hooks, an admin page and its resource definition.

3. Migrate, seed and run.

grit migrate
grit seed
grit start

4. Look at what you have. At http://localhost:3001 there is an Issues screen with sorting, filtering, search, pagination and bulk selection; a create form with a rich-text editor, two dropdowns and a searchable customer picker; and full CRUD behind role guards. At http://localhost:8080/docs is the API reference for the endpoints that back it, and at /studio a browser for the rows themselves.

5. Add a column later, without regenerating. It goes into the model, both Zod schemas, the TypeScript type, the admin form and the table, and GORM adds the column on the next grit migrate:

grit generate field Issue resolved_at:datetime

Scalar, select and toggle columns work this way. For a relationship, file, slug or array field, regenerate the resource.

6. Ship it.

grit deploy --host [email protected] --domain helpdesk.com

SSH, systemd and Caddy with automatic TLS. Deployment guides for Railway, Render, Fly.io, Coolify, Dokploy and plain VPS.

Longer walkthroughs: a CRM · a storefront · an invoice app · a mobile app · a desktop app

Let an AI build it

Grit is a code generator, and agents that do not know that hand-write the nine files and wonder why nothing is reachable. So there is a skill that teaches them:

npx skills add MUKE-coder/grit --skill grit

Then paste the build prompt, which sets out the whole job in nine steps, links every concept the agent needs, and tells it to ask you what you are building before it scaffolds anything:

curl -s https://gritframework.dev/prompt

Or copy it from gritframework.dev/docs/ai-integration, which also has a wizard that narrows the brief to your stack and plugins. The skill itself is readable at gritframework.dev/skill.md, and there is an MCP server for tools that speak it.

Plugins: whole features, generated

grit plugin add writes a feature into your project as code you own. grit plugin update brings in fixes later without overwriting a file you have edited, and grit plugin remove reverses every file and every injection.

grit plugin add stripe            # one-off payments and subscriptions, webhook-verified
grit plugin add push              # push notifications to iOS and Android via Expo
grit plugin add video             # uploads converted to web-ready MP4 with posters
grit plugin add webhooks          # outgoing webhooks, signed to the Standard Webhooks spec
grit plugin add multitenant       # organisations, per-org roles, automatic query scoping
grit plugin add impersonate       # sign in as a user, with an audit trail
grit plugin add command-palette   # ⌘K across the admin
grit plugin add saved-views       # per-user named table views
grit plugin add device-pairing    # sign in a browser by scanning a QR from a signed-in phone

Choose an architecture

Frontend: --next (App Router, default) or --vite (TanStack Router, SPA). Database: --db postgres|mysql|sqlite|memory. grit new . scaffolds into the current directory.

Architecture guide

Field types

The field definition is the source of truth for the column, the validation, the type and the admin input.

Modifiers: :unique :optional :encrypted :slug:<source> :belongs_to:<Model> :many_to_many:<Model> :select:a=A|b=B :file:image

Full reference

# Scaffolding
grit new <name>                        # interactive
grit new <name> --triple --next        # explicit
grit new-desktop <name>                # desktop app (Wails)

# Generating
grit generate resource <Name> --fields "..."   # also: grit g
grit generate resource <Name> --seed --faker --count 500
grit generate field <Resource> <name:type>     # one column, in place
grit generate seeder <Resource>
grit generate migration <name>                 # a SQL pair for what AutoMigrate cannot do
grit generate migration <name> --index t:col   # CREATE INDEX CONCURRENTLY, done right
grit generate form <Resource>                  # multi-step form
grit generate table <Resource>
grit remove resource <Name>                    # reverses every injection
grit add role <ROLE>
grit add variants --resource <Resource>
grit sync                              # Go types -> TypeScript + Zod

# Running
grit start                             # everything
grit start server | grit start client
grit studio                            # GORM Studio
grit routes                            # what is actually mounted
grit doctor                            # audit for silent security mistakes

# Database
grit migrate                           # run migrations
grit migrate --fresh | status | down
grit migrate down --sql                # undo the most recent SQL migration
grit seed
grit backup | grit restore

# Plugins
grit plugin list | add <name> | remove <name> | update

# Operations
grit down                              # maintenance mode
grit up
grit deploy --host user@server --domain example.com

# Meta
grit version | grit update             # the CLI
grit upgrade                           # this project's templates

grit plugin list
grit plugin add multitenant       # organizations, per-org roles, query scoping
grit plugin add impersonate       # sign in as another user, with an audit trail
grit plugin add command-palette   # ⌘K navigation
grit plugin add saved-views       # per-user named table views
grit plugin add stripe            # checkout, subscriptions, webhooks
grit plugin add push | video | webhooks | device-pairing

Released carefully, often

Grit ships almost daily. Every release scaffolds fresh projects in every shape, builds them, lints them and runs their tests, then re-verifies against the published binary. Fixes reach existing projects through grit upgrade, which never overwrites a file you have edited: it tells you what it could not change, and why. Every release is explained in plain language in the changelog.

When not to use Grit

Better to say this now than waste your weekend.

• Your core is an unusual data model or request lifecycle. Grit is at its best on CRUD-shaped products with an admin surface.
• Your team is all TypeScript, and one language everywhere matters more to you than a Go backend. AdonisJS or Nest will suit you better.
• Data science or ML is the product. Python's ecosystem wins there, and it is not close.
• You would rather depend on a library than own generated code. Grit's output is yours to maintain. Upgrades patch what they safely can; code you have rewritten is your own.

The full reasoning, including what each decision costs, is in Why Grit.

Documentation

gritframework.dev has the guides, the tutorials, the API reference and the free 10-part course.

Start at /docs/start, which is one ordered route from nothing to deployed. What is stable and what is not. Changelog (CHANGELOG.md).

Community

• WhatsApp community: questions, help, and the person who builds Grit. No question is too small.
• Discussions: ideas, and anything that needs more than a chat message.
• Issues: defects. The template asks for the version, the steps and the output, which is what decides whether a bug is fixed this week or waits for a reply.
• Star the repo if Grit saved you a week. It is how other developers find it.

Sponsors

Grit is free and MIT licensed. Sponsorship pays for the features, docs and releases everyone else gets for free, and puts your name in front of every developer who builds with Grit.

Grit has no sponsors yet. Be the first. Your logo goes here, on the home page, and inside the CLI.

Become a sponsor →

Building with Grit? Add the badge:

[![Built with Grit](https://gritframework.dev/badge/built-with-grit.svg)](https://gritframework.dev)

Contributing

Bug reports, fixes and documentation corrections are welcome and merged quickly. Anything larger is worth an issue first, because a change here lands in every project built afterwards. CONTRIBUTING.md has the setup, the layout of the repository and what gets merged quickly.

Questions and ideas belong in Discussions rather than the issue tracker.

Code of Conduct

Taking part in this project means agreeing to abide by its Code of Conduct.

Security

If you find a security problem, please do not open an issue. SECURITY.md says how to report it privately, what is in scope, and how releases are signed and verified.

License

MIT