>
dbwarden
GitHub ↗
/ wlite + libwlite

A Small Schema Engine
for Every Runtime.

wlite and libwlite are the lower-level pieces of the dbwarden ecosystem: a compact schema language, planner, and migration engine that can run without Python.

/ 01 The pairRead the docs ↗

One engine, two ways to use it.

libwlite is the embeddable C library. It parses schema definitions, introspects database state, computes diffs, builds migration plans, and emits SQL without requiring an application framework.

wlite is the user-facing CLI built on that engine. It adds a practical workflow for migrate, diff, plan, compile, snapshots, and schema hashes, plus C++, Python, and Rust bindings.

They are related to dbwarden, not a dbwarden plugin. dbwarden is the model-native SQLAlchemy workflow; wlite is the portable schema engine underneath the language boundary.

the workflow
schema definition -> parse -> introspect -> diff -> plan -> migrate
/ 02 libwliteRead the docs ↗

The portable core.

The C library keeps the core operations small and composable. Applications can embed parsing, schema introspection, planning, and SQL generation directly, then keep their own runtime, deployment model, and language bindings around it.

It is designed for predictable tooling rather than a large framework: schema state can be snapshotted and hashed, changes become typed plan operations, and the generated SQL remains inspectable before it is applied.

library surface
parse | introspect | snapshot | diff | plan | emit
Explore libwlite on GitHub ↗
/ 03 wliteRead the docs ↗

A CLI for the same engine.

Use the CLI when you want the engine’s workflow from a shell, CI job, or deployment image. Compile a schema, inspect a plan, compare snapshots, or run a migration without bringing an application framework into the process.

The bindings expose the same engine to C++, Python, and Rust programs. That makes wlite useful at the edge of a system too: a service can own schema changes in its native runtime while sharing the same state and migration semantics.

inspect before apply
$ wlite compile schema.wl --output schema.sql
$ wlite snapshot app.db --output state.json
$ wlite diff state.json schema.wl
$ wlite plan schema.wl
$ wlite migrate app.db schema.wl
Read the wlite documentation ↗
/ choose the layer
Choose libwlite

You are embedding schema and migration behavior into a native application or building another binding.

C library repository ↗
Choose wlite

You want the ready-to-run CLI, portable bindings, and a compact workflow for compile, diff, plan, snapshot, and migrate.

CLI and bindings repository ↗
Choose dbwarden

You use SQLAlchemy models as the source of truth and want generated SQL migrations with database-aware metadata.

dbwarden repository ↗
/ faq
Is wlite a dbwarden plugin?

No. wlite and libwlite are related projects in the ecosystem, not plugins. dbwarden provides the SQLAlchemy and Python workflow; wlite provides a portable lower-level engine and CLI.

What languages does wlite support?

The engine is written in C, with C++, Python, and Rust bindings in the wlite repository.

Can wlite and dbwarden be used together?

Yes, where their artifacts or responsibilities meet. Use dbwarden for model-driven SQLAlchemy migrations and wlite when a portable schema engine, native binding, or framework-independent migration tool fits better.