Suprnova is a web framework for Rust that gives you Laravel's developer
experience on top of Tokio. You write controllers and Eloquent-style models;
the framework gives you concurrency, type safety, and a single-binary
deploy. Today we're opening it up: the framework, two starter kits, a
100-plus-chapter manual, and this site.

```rust
use suprnova::{model, Model};

#[model(table = "users")]
pub struct User {
    pub id: i64,
    pub name: String,
    pub email: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub updated_at: chrono::DateTime<chrono::Utc>,
}

// Then anywhere:
let user = User::find(42).await?;
let admins = User::query().db_where("role", "admin").get().await?;
```

If you wrote that in Laravel last week, the Rust version will feel
identical - same chain shape, same method names, same defaults. The
difference is what happens underneath: Tokio instead of FPM, one binary
instead of a PHP runtime, compile-time type checks on every column.

## Why we built it

Laravel solved the productivity problem for backend web development. After
a decade of refinement, very little gets in your way when you're building a
real product. But PHP's request-per-process model keeps two things
permanently out of reach: cheap long-lived connections and trivial
concurrent I/O inside one request handler.

Rust gives you both for free. The problem is that the Rust web ecosystem
makes you build the productivity layer yourself - pick an HTTP crate, an
ORM, a migration tool, a queue, then wire it together and invent your own
conventions. Every app rebuilds what Laravel standardised years ago.

Suprnova copies Laravel's conventions onto Tokio so you don't have to.

## What's in the box

One binary is the web server, the migrator, the queue worker, the
scheduler, and the workflow engine. On top of hyper, SeaORM, and Inertia,
you get the surface you already know: `routes!`, `Auth::user()`,
`Cache::remember`, `Mail::send`, `Queue::push`, `Storage::disk`,
`Gate::allows`, the Eloquent query builder, soft deletes, factories,
observers, events, broadcasting, rate limiting, and a testing story with
fakes for every one of those surfaces.

Every subsystem with plausible alternatives is a trait with swappable
drivers - cache, queue, mail, storage, vector search, payments,
broadcasting - selected by config, not by forking the framework.

The frontend is Inertia with generated types: change a Rust prop struct,
run `suprnova generate-types`, and the TypeScript compiler points at every
component that needs updating. Svelte 5, React 19, and Vue 3.5 starters
ship in the scaffold.

## Starter kits

`suprnova new` scaffolds a bare app. When you want more than bare, there
are two first-party kits: **Nebula**, an application starter with
authentication and a console, and **Pulsar**, a publishing platform with
docs, articles, RSS, moderation, and an admin - the kit this site is built
on.

## Honest words about maturity

Suprnova is pre-1.0 and distributed by git tag - the
`v<version>` tag is the release. That's deliberate: the API is still
absorbing real-world feedback, and tags let us ship improvements without
pretending SemVer stability we don't have yet. The framework carries about
3,400 tests, denies undocumented public items at compile time, and every
release runs a full gate before it tags. When the surface settles, crates.io
follows.

## Get started

```sh
cargo install --git https://github.com/eas4ai/suprnova.git --tag v0.9.1 suprnova-cli
suprnova new my-app
cd my-app && suprnova serve
```

The [manual](/docs) covers everything from the quickstart to workflows,
broadcasting, and deployment - including dedicated chapters if you're
coming from Laravel or from the Rust web ecosystem.

If you build something, get stuck, or think we got a default wrong, we want
to hear about it on
[GitHub issues](https://github.com/eas4ai/suprnova/issues).