🧩 Two paradigms, one core
The typed query builder and the declarative orm share one Session, one
dialect, one scanner, one set of errors. A row fetched via orm feeds query
on the same transaction — no library lock-in, no camp to pick.
LiteORM for modern Go
A typed query builder and a declarative ORM over one CGo-free core. LiteORM is lite because it's modern — built from a clean Go baseline, not a decade-old codebase patched a thousand times — so it ships more, not less.
One library, two front-ends over one core: an explicit, generics-first query
builder and a declarative, convention-driven orm — same backends, same
transaction, same normalized errors. Use orm for CRUD and drop to query for a
hot path on the same connection. SQLite is CGo-free; Postgres, MySQL, and SQL
Server are first-class too.
Why LiteORM
Section titled “Why LiteORM”⚡ Modern baseline, lean core
Generics-first, no hot-path reflection. The core pulls in zero drivers —
each backend is its own module. SQLite is pure Go: cross-compile with plain
go build, ship static binaries, no C toolchain — and open it encrypted at
rest, still pure Go, no CGo sqlcipher.
🤖 Built for agents
An embedded studio with AI built in turns plain English into SQL, and
shipped Agent Skills + AGENTS.md mean your coding assistant writes correct
LiteORM the first time. AI for the people using and building your database.
🎯 Safe by default
No implicit lazy loading — eager Load is N+1-safe by construction. Soft-delete
is an explicit tri-state scope. Constraint and not-found errors normalize to the
same sentinels on every backend.
LiteORM Studio
Section titled “LiteORM Studio”The first Go ORM with an embedded database studio — browse, filter, edit, follow foreign keys, and run SQL right in the browser, mounted as a stdlib http.Handler behind your own auth. And AI is built in: describe a filter or a whole query in plain English and get SQL back, with result sets charted automatically.
What you get
Section titled “What you get”Two front-ends are the floor. Stacked on top, in the same library:
Query builder query.Select[T] with typed Col[V] predicates, joins, set ops, subqueries, CTEs, window functions, streaming, and a Raw[T] escape hatch.
Declarative ORM Models from orm: (or gorm:) tags, additive AutoMigrate, a CRUD Repo, associations with N+1-safe eager loading, typed hooks, and soft delete.
Studio + AI The first Go ORM with an embedded database studio: a browser admin GUI mounted as an http.Handler, with natural-language→SQL and auto-charted results via one server-side WithAI hook.
Normalized errors ErrUniqueViolation, ErrForeignKey, ErrNoRows, ErrDeadlock and more — the same sentinels on SQLite, Postgres, MySQL, and SQL Server.
Migrations Additive AutoMigrate plus a two-track model: destructive changes become a reviewable migration applied through a thin runner.
Code generation Typed Column[V] constants, models from a live DB, SQL→typed-Go, a sqlc plugin, and a gorm→LiteORM tag porter. Opt in per need.
SQLite vector / FTS / hybrid search Typed vector (sqlite-vec) and FTS5 search, plus reciprocal-rank-fusion hybrid search keyed by your model's primary key.
Encryption at rest Open an encrypted SQLite database with a 32-byte key: transparent page-level encryption (Adiantum), pure Go — no CGo sqlcipher. The query builder, ORM, and migrations all work unchanged above the ciphertext.
SQLite changesets Capture, apply, invert, and concat changesets — for audit logs, one-way replication, and undo.
Postgres extras LISTEN/NOTIFY and typed JSONB and array operators — keys and values always bound, never interpolated.
Quick start
Section titled “Quick start”import ( "liteorm.org/dialect/sqlite" "liteorm.org/orm" "liteorm.org/query")
db, _ := sqlite.Open("app.db")defer db.Close()
// Declarative: tag a model, migrate, CRUD.type Author struct { ID int64 Name string Email string `orm:"email,unique"`}func (Author) TableName() string { return "authors" }
_ = orm.AutoMigrate[Author](ctx, db)authors := orm.NewRepo[Author](db)_ = authors.Create(ctx, &Author{Name: "Ada", Email: "ada@example.com"})
// Explicit: typed predicates on the same DB.hits, _ := query.Select[Author](db). Filter(query.Col[string]("email").Like("%@example.com")). OrderBy("name").All(ctx)Add the core plus the backend you want — the core pulls in zero drivers. Full setup in Getting started.
How it compares
Section titled “How it compares”LiteORM is the only Go library that puts a typed query builder and a declarative ORM over one core — so every win below holds across both front-ends, not just one.
| Capability | LiteORM | gorm | bun | sqlc | ent |
|---|---|---|---|---|---|
| Query builder and declarative ORM in one library | – | – | – | ||
| Generics-first runtime, no hot-path reflection | – | ||||
| CGo-free SQLite (pure Go, no C toolchain) | |||||
| At-rest encrypted SQLite, pure Go (no CGo sqlcipher) | – | – | – | – | |
| Embedded database studio (admin GUI) in-tree | – | – | – | – | |
| Studio with built-in AI (NL→SQL, charts) | – | – | – | – | |
| Ships AI Agent Skills + task-oriented docs | – | – | – | – | |
| Typed joins, set ops, subqueries, CTEs, windows | – | ||||
| Associations + N+1-safe eager load | – | ||||
| Normalized errors across all backends | – | – | – | – | |
| Migrations: additive auto + reviewable destructive | – | ||||
| Codegen: typed columns / models / SQL→Go | – | – | |||
| SQLite vector + FTS5 + hybrid search, changesets | – | – | – | – |