A Laravel-inspired web framework for Rust.

Rust full-stack framework

A Laravel-inspired web framework for Rust.

Suprnova gives you Laravel 13's developer experience - routes!, Eloquent models, Auth::login, queues, and an Inertia bridge - on a hyper / SeaORM / Tokio stack. One binary, async everywhere, type-checked end to end.

Terminal Copy

$ cargo install --git \
    https://github.com/eas4ai/suprnova.git \
    --tag v3.2.1 suprnova-cli
$ suprnova new my-app --frontend svelte
$ suprnova serve   # http://localhost:8765

Get startedRead the manualStar on GitHub

Requires Rust 1.94.0+

src/http/routes.rsRust

routes! {
    get!("/",             home),
    get!("/posts/{post}", show),
    post!("/posts",       store).middleware(Authenticate),
}
#[handler]
async fn home(req: Request) -> Response {
    let popular = Cache::remember("posts.popular", Some(Duration::from_secs(60)), || async {
        Ok(Post::query().db_where_op("views", ">", 1000).get().await?.into_vec())
    })
    .await?;
    inertia_response!(&req, "Home", { "posts": popular })
}

cargo build: 0 errorsserving :8765inertia · svelte 5

Familiar API surfaceroutes!, Eloquent, Auth::user(), Cache::remember - the Laravel habits you already have.

Async on TokioLong-lived connections and concurrent I/O as first-class citizens. No request-per-process.

Type-safe end to endModels, routes, and Inertia props checked at compile time. Prop drift fails the build, not staging.

Single-binary deployOne self-contained binary. No FPM, no opcache, no runtime to babysit.

Batteries included

Everything a real product needs, already wired.

Laravel 13's surface, domain by domain, reimagined for Rust - with an honest parity map for the gaps. Every backend-bearing subsystem is a trait with drivers - you pick the tool, the framework doesn't gatekeep.

HTTP & routing

routes! macro, named routes, groups, route-model binding, signed URLs and resource routing - 100% type-checked.

Eloquent ORM

#\[model\], 11 relation kinds, eager loading, soft deletes, scopes, observers, factories and three paginators.

Auth, guards & 2FA

Sessions, named guards, TOTP two-factor, email verification, password reset, policies and gates.

Queues & workflows

Memory / Redis / database queues, batches, chains, retries - plus durable #\[workflow\] steps that survive restarts.

Realtime

Typed WebSocket handlers, public / private / presence channels, server-sent events and Web Push.

Cache, storage & vector

Redis cache with tags and locks, local / S3 filesystem, and vector search across Qdrant, Pinecone and MariaDB.

Mail & notifications

SMTP, SES, Mailgun, Postmark, SendGrid and Resend - with mail, database, broadcast and web-push channels.

Testing

#\[suprnova\_test\], in-memory SQLite, and fakes for Mail, Queue, Event and Broadcast baked in.

…plus payments (Stripe · Paddle), feature flags, scheduling, observability and idempotency - see the full subsystem map in the manual.

End-to-end types

Define it in Rust. Use it in TypeScript.

Derive InertiaProps once, run `suprnova generate-types`, and your frontend types mirror the Rust shape exactly - Svelte 5, React 19, or Vue 3.5.

Refactors stay honest

Change a field, regenerate, and the compiler points at every component that needs to update.

app/http/home.rsRust

// Define your props in Rust, once.
#[derive(InertiaProps)]
pub struct HomeProps {
    pub title: String,
    pub posts: Vec<PostDto>,
}
#[handler]
pub async fn index(req: Request) -> Response {
    inertia_response!(&req, "Home", HomeProps {
        title: "Welcome".into(),
        posts: Post::all().await?.into_vec(),
    })
}
// $ suprnova generate-types
// -> frontend/src/types/inertia-props.ts

Two ways in

Pick the path that matches your background.

From Laravel

You know routes, Eloquent, Auth::user(), php artisan, queues and Blade. We translate every habit you have into its Suprnova equivalent - typed.

Start from Laravel

From Rust web

You know Axum, Actix or Rocket. Add a full-stack productivity layer: codegen, an Eloquent-style ORM, and an Inertia bridge to the frontend.

Start from Rust web

Start from a kit

Don't start from an empty scaffold.

Fork a ready-made application - routes, migrations, frontend pages and tests already wired. Two kits ship today.

Nebula

Svelte 5

Authentication · Breeze-tier

Registration with email verification, login with remember-me, password reset, and profile management on Inertia 3 + Svelte 5. The clean account foundation to build on.

Fork Nebula

Pulsar

Vue 3.5

Product site & community

Everything in Nebula plus a marketing landing, dashboard, a Markdown docs pipeline, a blog with RSS, member profiles, taxonomy and role-based access control - on Vue 3.5 + Vuetify.

Explore Pulsar

Neither fits? `suprnova new my-app --frontend svelte` (or `react`, or `vue`) ships a working auth flow on a plain scaffold. API-only? `suprnova new my-api --api`.

Built with Suprnova

Ship real products, not demos.

Submit your project

EAS4AIEngineered Automated Systems for AI - production open source across the whole AI stack. The site runs Suprnova with Inertia SSR in production.Svelte 5SQLiteInertia SSRNation XA social network for creators of every kind - and the services they work with - rebuilt from Laravel onto Suprnova.Svelte 5PostgresRedisAudeeOZPrecision-engineered VST3, CLAP and AU plugins for mixing and mastering, with a web home built on Suprnova.Vue 3.5SQLite

Your project could be here - open an issue and tell us what you're building.

The manual

100+ chapters. Every public subsystem.

Organised the way Laravel's docs are - pick a chapter and go. Renders straight from Markdown on GitHub, no build step, no SaaS dependency.

Read the manualQuickstart

PrologueGetting startedArchitecture conceptsThe basicsDigging deeperSecurityDatabaseEloquent ORMTestingPaymentsFrontendCLIDeploymentTutorialsReference

Ship a Rust product without the boilerplate.

Install the CLI, fork a kit, and you're serving on `:8765` in minutes.

Get startedGitHub