Batteries-included velocity,
the Rust way.
Gize is a productivity-first backend framework for Rust. Scaffolding, conventions, generators, migrations and an admin, with zero magic and generated code you fully own.
The name comes from the plateau of the Great Pyramids: solid foundations meant to last.
The problem
Rust is fast. Starting a Rust backend is slow.
Rust is excellent for backend services: fast, safe, predictable. But standing up a real-world backend is slow: you pay a high “day-one tax” before writing a single line of business logic.
No blessed layout
Every team reinvents its own project structure from scratch.
Manual wiring
Router, database pool, migrations, config, auth and error handling, all by hand.
Hand-written resources
Model → migration → repository → service → DTO → handler → routes → tests, entirely manual.
No conventions
No first-class admin, no scaffolding, no shared conventions to lean on.
The result: teams avoid Rust for CRUD-heavy products, or burn days on boilerplate. Gize targets exactly this pain: initial productivity.
How it works
From zero to a running API in minutes
A handful of commands produce a compiling, running, production-shaped API with a full CRUD resource, in idiomatic Rust you can read and own.
- 01
gize new shopScaffold the project
A Cargo project with the standard layout, config, DB pool, router, state and error handling. Compiles and serves an empty app.
- 02
gize make crud ProductGenerate a resource
Repository, service, DTO, handlers, routes, validation and tests, wired into the router automatically.
- 03
gize migrateApply migrations
Generate and apply SQL migrations for your models against PostgreSQL.
- 04
gize serveRun it
Boot the generated app and start hitting your GET/POST/PUT/DELETE endpoints.
Differentiators
Batteries included, never a black box
Transparent codegen
Everything Gize generates is normal Rust you can read, diff and edit. No runtime reflection, no proc-macro maze you can't escape.
Detachable batteries
Admin, auth and OpenAPI are opt-in crates, not a monolith you must swallow whole.
Manifest-driven, not locked
gize.toml describes the app and powers gize sync, but your hand edits are always respected.
Rust-native ergonomics
DTO validation, typed errors and async-first design map to how idiomatic Axum apps are already written.
Design principles
Non-negotiable
- Zero-cost abstractions.
- Generated code is idiomatic and readable, and the developer stays the owner.
- No unnecessary dependencies; each one is justified in an ADR.
- Convention over configuration, but customization is always possible.
- Predictable architecture, explicit code, performance as a priority.
- Built for real projects, not just demos.
The stack
Standing on best-in-class crates
Gize doesn't reinvent the runtime. It orchestrates proven crates behind clear conventions.
HTTP framework
Data access · PostgreSQL
Async runtime
CLI
Templating for codegen
10-crate architecture
Landscape
How Gize compares
We borrow the experience (conventions, scaffolding, productivity), not the magic.
| Tool | Strength | Where Gize differs |
|---|---|---|
| Plain Axum (Rust) | Minimal, unopinionated HTTP framework. | Uses Axum underneath, then adds layout, DB, migrations and scaffolding. You still get plain Axum code. |
| Actix Web (Rust) | Very fast, mature, actor-influenced. | Starts on Axum for a gentler ecosystem; the framework layer is abstracted so an Actix target stays a future option. |
| Loco (Rust) | The closest “Rails for Rust”, SeaORM-based. | Bets on generated-code transparency over a heavy runtime, and SQLx-first over SeaORM. |
| Rails (Ruby) | The generator/convention gold standard. | Same generator DNA, compiled and type-safe. Slower edit→run in exchange for performance and safety. |
| Laravel (PHP) | Artisan generators, great DX. | gize make ... is our artisan, producing explicit Rust repositories and typed queries instead of PHP. |
Scope
What Gize is not
Not a framework clone
We borrow the experience (conventions, generators, scaffolding), not the runtime model or the magic.
Not a black box
Generated code lives in your repo and is fully editable. No hidden runtime rewriting your handlers.
Not its own ORM or framework
Gize orchestrates best-in-class crates (Axum, SQLx, Tokio) behind clear conventions.
The ultimate test: delete Gize from your project and still have a working, idiomatic Rust codebase. Gize is a productivity accelerator, not a cage.
Roadmap
MVP → v1.0 in 18 months
Phases are gated: each starts only when the previous meets its acceptance criteria.
Build your Rust backend at framework speed.
Gize is in early development. Follow the vision, the MVP definition and the roadmap.