Modular Rust web framework · v0.0.11

Every capability is a plugin. Including auth.

Umbral gives Rust developers a complete web framework - models, migrations, admin, forms, REST, background work - with every capability delivered as a plugin you can enable, replace, or extend.

Get started Browse the plugin directory

Built with Umbral This whole site runs on Umbral - same apps, migrations, forms, admin & plugins it documents.

Plugins listed

in the live directory

Community plugins

approved & published

Models migrated

tracked by the engine

Lines of glue

to wire a new plugin

~/projects

$ umbral startproject blog
$ cd blog && umbral startapp posts

# enable capabilities, they're plugins, wired in main.rs
App::builder()
  .plugin(AdminPlugin::new())
  .plugin(RestPlugin::new())

$ cargo run -- makemigrations && cargo run -- migrate
✓ applied 3 migrations · admin at /admin

Swap any battery

Every official capability lives behind the same plugin contract a third party can use. Keep it, replace it, or build your own.

umbral.rest official

acme-graphql your pick

your-app/plugins/billing startapp

How Umbral works

Declare your data. Everything else - the schema, the admin, the API, the typed client - follows from it.

Declare a model

One Rust struct. The attributes carry the rules - length, timestamps, who wrote the row - so every write path enforces them, not just the one you remembered.

#[derive(Model)]
#[umbral(table = "post", audited)]
struct Post {
  id: i64,
  #[umbral(max_length = 200)]
  title: String,
  #[umbral(auto_user_add)]
  author: Option<FK<AuthUser>>,
  #[umbral(auto_now_add)]
  created_at: DateTime<Utc>,
}

Migrate

Umbral diffs your models against the last snapshot and writes the migration. Change the struct later and it writes the ALTER - the loop is the same on day one and day four hundred.

$ cargo run -- makemigrations
  + create table post

$ cargo run -- migrate
  ✓ 0001_create_post applied

Get the rest for free

Plug in what you want. An admin, a REST API, background jobs, realtime - each one is a plugin reading the same models, so none of it is scaffolding you maintain.

App::builder()
    .auto_models()
    .plugin(AdminPlugin::default())
    .plugin(RestPlugin::default())
    .build()?

// /admin      - CRUD, search, filters
// /api/post/  - REST, paginated
// gen-client  - a typed TS client

Every battery is a plugin, on the same contract a third-party crate uses - which is why you can swap any of them. This site runs on it.

First of its kind

One place to find a plugin for that

No Rust framework has a real home for discoverable, reviewable apps & plugins. Umbral does - search, filter, read what developers are saying, and check a plugin's safety before you install.

Open the directory

All Official Community Audited

A umbral-admin stable

model-aware CRUD, dashboards, audit trail, relation pickers

★ 0 0 downloads 2 notes

cargo add umbral-admin Unverified

A umbral-auth stable

users, groups, login routes, argon2, reset flows

★ 0 0 downloads 1 notes

cargo add umbral-auth Unverified

R umbral-rest usable

model resources, filters, search, pagination, safe writes

★ 0 0 downloads 2 notes

cargo add umbral-rest Unverified

One contract, every battery

Why everything is a plugin

The same boundary, first-party or third

Auth, sessions, admin, tasks and REST implement the exact trait a community plugin does. There is no privileged core path to special-case.

Own your migrations, end to end

Each plugin carries its own models and migrations. migrate orders them by a dependency graph - cross-plugin foreign keys included.

Replace a battery without a rewrite

Swap the default auth for your SSO, drop in a community GraphQL plugin - the admin, the ORM and the rest of your app keep working unchanged.

Wired in one line

Adding a plugin to your app is a single builder call - no registry edits, no glue module to maintain.

App::builder()
  .plugin(AdminPlugin::new())
  .plugin(RestPlugin::new())
  .build()?;

Every capability, a plugin

Official plugins maintained by the Umbral team. Each one is swappable, has its own page, and tracks what's shipped vs. planned.

umbral.orm

Model declaration, query ergonomics, multi-database direction.

Shipped

umbral.admin

Dashboards, CRUD, filters, sheets, bulk actions, preferences.

Shipped

umbral.rest

Serializers, viewsets, routers, OpenAPI, pagination, playground.

Shipped

umbral.auth

Sessions, password hashing, permissions and groups.

Shipped

umbral.forms

Validation, friendly errors, spam resistance, server rendering.

Shipped

umbral.content

Blog, pages, FAQ, media, redirects, banners, testimonials.

Beta

umbral.tasks

Background jobs, scheduling and retries behind a plugin.

Experimental

See all prebuilt plugins

Setup notes, compatibility and per-plugin feature trackers.

Explore

What developers say

Verified reviews of the framework - tied to real GitHub identities.

All reviews →

Backend Developer · Indie

Side project

★★★★

The declare → migrate → change → migrate loop is the thing I missed most coming from other Rust web stacks. Autodetection got the common cases right; the couple it flagged were genuinely ambiguous and better surfaced than guessed.

on 0.0.1 · Side project

Platform Lead · B2B SaaS

Internal tool

★★★★★

Auth, sessions, admin, REST — they're all plugins with the same shape as anything I'd write. I swapped the default auth for our SSO without touching the core. That's the dependency inversion working as advertised.

on 0.0.1 · Internal tool

Plugins run real code. We take that seriously.

Every plugin page has a one-click way to report a security concern. Confirmed issues get an advisory and a visible warning - triaged by dedicated plugin auditors.

Audit status on every listing

Responsible disclosure workflow

Ecosystem alerts for confirmed threats

Read the security model