KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #typescript #developer-tools #claude-code #ai-agent #codex #deepseek-harness #ai-agents #cli #react #mcp

suprnova

★ 33 Open GitHub ↗

Suprnova - A Laravel Inspired Full Stack Framework For Rust

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Suprnova

**A Laravel-inspired web framework for Rust.**

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![CHANGELOG](https://img.shields.io/badge/CHANGELOG-keep%20a%20changelog-orange)](https://raw.githubusercontent.com/eas4ai/suprnova/main/CHANGELOG.md)

![Suprnova - A Laravel-inspired web framework for Rust](https://raw.githubusercontent.com/eas4ai/suprnova/main/manual/suprnova_header.jpg)

Suprnova is a full-stack Rust web framework with Laravel 13's developer
experience and Tokio's runtime model. Familiar API surfaces - `Auth::login`,
`Cache::remember`, `Mail::to`, `Event::dispatch`, Eloquent-style models,
`#[handler]`, `#[command]`, `routes!` - sit on top of a hyper / SeaORM /
async-trait stack designed for long-lived connections, in-process workers,
and concurrent IO. No request-per-process compromise.

Suprnova 1.2 requires Rust 1.91.1 or newer.

```bash
cargo install --git https://github.com/eas4ai/suprnova.git --tag v1.2.0 suprnova-cli
suprnova new myapp --frontend svelte
cd myapp
suprnova serve
```

Your app is now serving at `http://localhost:8765`, with a Vite dev server
proxied for the frontend.

## Quick taste

If you've used Laravel, this should feel like home - only typed.

```rust
use std::time::Duration;
use suprnova::{handler, routes, attrs, inertia_response, json_response, Response};
use suprnova::{Auth, Cache, Event, RouteParam};
use crate::models::Post;
use crate::events::PostCreated;
use crate::requests::CreatePostRequest;

routes! {
    get!("/",             home),
    get!("/posts/{post}", show),
    post!("/posts",       store).middleware(Authenticate),
}

#[handler]
async fn home() -> Response {
    let popular = Cache::remember(
        "posts.popular",
        Some(Duration::from_secs(60)),
        || async { Post::query().db_where_op("views", ">", 1000).get().await },
    )
    .await?;
    Ok(inertia_response!("Home", { "posts": popular }))
}

#[handler]
async fn show(RouteParam(post): RouteParam<Post>) -> Response {
    Ok(json_response!({ "post": post }))
}

#[handler]
async fn store(req: CreatePostRequest) -> Response {
    let post = Post::create(attrs! {
        user_id: Auth::id().ok_or_else(|| FrameworkError::Unauthorized)?,
        title:   req.title,
        body:    req.body,
    })
    .await?;
    Event::dispatch(PostCreated { post: post.clone() }).await?;
    Ok(inertia_response!("Posts/Created", { "post": post }))
}
```

`RouteParam<Post>` applies the model's global scopes and soft-delete
filter automatically. `Post::query()` is the Eloquent builder
(`db_where_op` is the Laravel-side alias of `filter_op` for arbitrary
SQL operators). The `#[handler]` macro pulls FormRequests out of the
body, route params out of the URI, and authenticated users out of the
session - all type-checked.

## What's in the box

The Laravel-13 parity surface plus the Rust-native wins:

| Layer | What ships |
|---|---|
| **HTTP & routing** | `Router`, named routes, route groups & prefixes, parameter binding, resource routing, signed URLs, redirect helpers (`Redirect::to`/`back`/`route`/`with_errors`/…), `#[handler]` macro, 100% type-checked |
| **Middleware** | CORS, CSRF, session, request-timeout, request-id, throttle / login-throttle, signed-URL verify, authenticated, email-verified, brute-force, custom global/group/per-route |
| **Inertia 3 bridge** | `InertiaProps` derive + TypeScript codegen, partial reloads, deferred / lazy props, version mismatch handling, SSR loopback, `#[handler]` integration, three starters: **Svelte 5 / React 19 / Vue 3.5** |
| **Eloquent ORM** | `#[suprnova::model]` macro, 11 relation kinds (hasMany / belongsToMany / morph / polymorphic / through), eager loading, soft deletes, observers, global & local scopes, casts, 16 lifecycle events, factories + seeders, `Collection<M>`, 3 paginators, chunk/lazy/cursor iteration, multi-connection R/W split, transactions + savepoints + retry-on-deadlock |
| **Auth** | `Auth::user`/`login`/`once`/`check`, named guards via `AuthManager`, remember-me, 2FA TOTP with recovery codes, email verification, password reset, brute-force lockout, login throttle, role/permission gates, `#[policy]` registration |
| **Database** | SeaORM-backed migrations + entity codegen, four databases: **SQLite / Postgres / MySQL / MariaDB** (MariaDB rides the MySQL driver and adds a native vector driver), `DB::transaction` with savepoints, query logging, multi-connection registry |
| **Cache** | Memory, file, Redis - `Cache::remember` + lock-based `Cache::lock` + tags + atomic Redis Retry-After |
| **Queues & jobs** | Memory, sync, Redis, database - queue routing (`Queue::route`, `Job::queue`, `queue:work --queue=billing`), middleware pipeline, batches, chains, retry schedules, failed-job store, unique jobs |
| **Events & bus** | `Event::dispatch`, `Listener`/`Subscriber`, queued listeners, panic-isolated dispatcher, command/query bus |
| **Notifications** | Mail / database / broadcast / Web Push channels, anonymous notifications, deferred dispatch |
| **Mail** | SMTP, Mailgun, Postmark, SendGrid, Resend, SES, log + in-memory transports, Markdown templates via Tera, fake() helper, queued mail |
| **Broadcasting & WebSocket** | Channels (public / private / presence), `BroadcastHub` trait, sea-streamer fanout adapter, JSON-envelope protocol, supervised heartbeats with auto-restart |
| **Filesystem** | Local + S3 (R2 / B2 / MinIO compatible) via OpenDAL, path-traversal guard, atomic copy |
| **Vector** | Memory, **Qdrant**, **Pinecone**, **MariaDB native `VECTOR(N)`** (HNSW + cosine/euclid/L1/L2) - first-class trait + drivers, no Postgres-only gatekeeping |
| **Payments** | Generic `Payment` / `Subscription` / `CustomerStore` / `WebhookHandler` traits + DB mirror; **Stripe** and **Paddle** reference adapters; webhook UNIQUE idempotency |
| **Validation** | `Required`, `Email`, `Min`/`Max`/`Between`, `RequiredIf`/`With`/`WithAll`/`Unless`, `Unique` (async), `Confirmed`, custom rules via traits, `validator` derive integration |
| **Scheduling** | `Schedule::call` / `command` / `job`, cron expressions, `runInBackground`, `withoutOverlapping`, supervised execution |
| **Workflows** | Durable steps via `#[workflow_step]`, `#[workflow]` orchestration, panic-recovery on the queue, exponential backoff with strict caps |
| **Console** | Per-project `console` binary (the Rust analogue of `php artisan`), `#[command]` + `#[derive(Command)]` typed args, `make:*` generators, `db:seed` |
| **Observability** | Structured `tracing` everywhere, request IDs end-to-end, OpenTelemetry support, DB query logging via `QueryExecuted` events |
| **Testing** | `#[suprnova_test]`, in-memory SQLite via `TestDatabase`, fakes (`Mail::fake()`, `Queue::fake()`, `Event::fake()`, `BroadcastHub` recorder), `expect!` macro, `handle_request` in-process driver |
| **Feature flags** | `DatabaseEvaluator` + `CachedEvaluator` + admin CRUD + sub-second propagation via `FeatureSync` |
| **Idempotency, rate-limit, CORS, CSRF, sessions, hashing, crypto** | First-class; each subsystem ships fail-open vs fail-closed as an explicit policy choice |

## Starter kits

Don't start from an empty scaffold (unless you want to o_O) - fork a kit:

- **[Nebula](https://github.com/eas4ai/Nebula)** - authentication
  (Breeze-tier): register, email verification, login with remember-me, password
  reset, and profile management, on Inertia 3 + Svelte 5.
- **[Pulsar](https://github.com/eas4ai/Pulsar)** - a full product site
  and community on Vue 3.5 + Vuetify: everything in Nebula plus a marketing
  landing, dashboard, a Markdown docs pipeline, a blog with RSS, member
  profiles, taxonomy, role-based access control, and admin/moderation surfaces.

See **[Starter Kits](./manual/starter-kits.md)** for the full rundown, or run
`suprnova new` for the plain scaffold on any of the three frontends.

## End-to-end type safety

Define props in Rust once; use them in TypeScript with full autocomplete.

```rust
use suprnova::{handler, InertiaProps, inertia_response, Response};

#[derive(InertiaProps)]
pub struct HomeProps {
    pub title: String,
    pub user: UserDto,
}

#[derive(InertiaProps)]
pub struct UserDto {
    pub name: String,
    pub email: String,
}

#[handler]
pub async fn index() -> Response {
    Ok(inertia_response!("Home", HomeProps {
        title: "Welcome!".into(),
        user: UserDto {
            name: "Ada".into(),
            email: "ada@example.com".into(),
        },
    }))
}
```

Run `suprnova generate-types` and your `frontend/src/types/inertia-props.ts`
mirrors the Rust shape exactly. Change a field, regenerate, the compiler
points at every component that needs to update.

## Durable workflows

Workflow steps survive process restarts and retry with exponential backoff
+ jitter (strict cap, no doubling past it):

```rust
use suprnova::{workflow, workflow_step, start_workflow, FrameworkError};

#[workflow_step]
async fn fetch_user(user_id: i64) -> Result<String, FrameworkError> { ... }

#[workflow_step]
async fn send_welcome_email(user: String) -> Result<(), FrameworkError> { ... }

#[workflow]
async fn welcome_flow(user_id: i64) -> Result<(), FrameworkError> {
    let user = fetch_user(user_id).await?;
    send_welcome_email(user).await?;
    Ok(())
}

// Enqueue & run the worker:
let handle = start_workflow!(welcome_flow, 123).await?;
```

```bash
suprnova workflow:work
```

## Documentation

- **[Manual](./manual/README.md)** - 100+ chapters, every public subsystem.
  Pick a reading path: [From Laravel](./manual/from-laravel.md) (if you
  know `Auth::user()` / Eloquent / Blade) or
  [From Rust Web](./manual/from-rust-web.md) (if you know Axum / Actix / Rocket).
- **[Quickstart](./manual/quickstart.md)** - small app end-to-end.
- **[CHANGELOG.md](./CHANGELOG.md)** - keep-a-changelog format.
- **[Introduction](./manual/introduction.md)** - the design principles the
  framework is built on, including why every backend-bearing subsystem is a
  trait with drivers rather than one blessed implementation.
- **[Contributing](./manual/contributions.md)** - the working agreement:
  **full implementations only, well tested, production-ready.** A feature
  ships when it's done, not when it has a prototype.

## Distribution model

Suprnova distributes via git, not crates.io. Generated apps depend on
`suprnova = { git = "https://github.com/eas4ai/suprnova.git", tag = "v1.2.0" }`;
the CLI installs via `cargo install --git`. Adapter crates
(`suprnova-payments-stripe`, `suprnova-payments-paddle`,
`suprnova-web-push`) follow the same model. The tag *is* the release:
an app moves versions by editing one `tag =` line, each version's
[CHANGELOG](./CHANGELOG.md) section is its release record, and as of
v1.0.0 breaking changes land only behind a version bump that says so.

## License

MIT, © 2026 Shawn McAllister & Dayem Siddiqui - see [LICENSE](./LICENSE).
Suprnova began as a fork of [Kit](https://github.com/dayemsiddiqui/kit)
(MIT, © Dayem Siddiqui) and has since been taken in its own direction.

suprnova

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README