Laravel's productivity.
Rust's guarantees.

002 Batteries included

Everything a real app needs. Already wired.

Not a starter template: a framework you depend on, tested as one piece on SQLite and PostgreSQL, on Linux, macOS and Windows.

• 001⌁

  Routing & requests

  Named routes, groups, domains, guards, rate limits, signed URLs, route model binding.

  Routes::new().get("/", home) Read the routing & requests guide →
• 002▤

  Models & migrations

  A query builder that checks column names, relations without N+1, migrations with batches, SQLite or PostgreSQL.

  #[derive(Model)] Read the models & migrations guide →
• 003✓

  Validation

  Form requests as structs with Laravel's rules, hooks, live validation, errors placed next to the field.

  Valid<NewOrder> Read the validation guide →
• 004⚿

  Auth & permissions

  Login, registration, reset, verification, API tokens, roles per tenant, policies, two-factor login, OAuth.

  .require_permission("orders.refund") Read the auth & permissions guide →
• 005⟳

  Queues & scheduler

  Jobs with retries, chains and batches; a cron scheduler that is safe across servers. No Redis needed.

  state.queue.dispatch(SendInvoice { … }) Read the queues & scheduler guide →
• 006✉

  Mail & notifications

  SMTP with failover, mail views, notifications by mail, in the database and as a live stream.

  state.notify(user, &OrderShipped { … }) Read the mail & notifications guide →
• 007▦

  UI kit, grid & HTMX

  72 accessible components, 112 icons, an editorial theme, a data grid with exports, and renox-blocks; htmx and Alpine.js built in.

  {{ grid(orders) }} Read the ui kit, grid & htmx guide →
• 008⬢

  One-binary deploys

  Views, translations, migrations and assets compiled in; systemd socket activation, so restarts refuse no connection.

  rnx build Read the one-binary deploys guide →

003 Under the hood

Every request goes through a pipeline you don't have to build.

Security headers, sessions, CSRF, auth and error pages are on from the first line. Hover a layer to see what it does.

004 Coming from Laravel?

You already know Renox. The compiler just checks your work now.

Route::get('/orders', [OrderController::class, 'index'])
    ->name('orders.index')
    ->middleware('auth');

Route::post('/orders', [OrderController::class, 'store'])
    ->name('orders.store')
    ->middleware(['auth', 'throttle:10,1']);

Routes::new()
    .get("/orders", index).name("orders.index")
    .post("/orders", store).name("orders.store")
    .throttle(10, Duration::from_secs(60))
    .require_auth()

class Order extends Model
{
    use SoftDeletes;

    protected $fillable = ['customer_id', 'total'];

    public function customer()
    {
        return $this->belongsTo(Customer::class);
    }
}

#[derive(Model, Serialize, Default)]
#[model(soft_deletes)]
pub struct Order {
    pub id: i64,
    pub customer_id: i64,
    pub total: i64,
    pub deleted_at: Option<DateTime>,
}

// The customers of a page of orders, in one query:
let customers = belongs_to::<Customer, _, _>(
    &db, &orders, |o| o.customer_id,
).await?;

class StoreOrder extends FormRequest
{
    public function rules(): array
    {
        return [
            'email' => 'required|email',
            'quantity' => 'required|integer|min:1',
        ];
    }
}

#[derive(Deserialize, Validate)]
pub struct StoreOrder {
    #[validate(required, email)]
    pub email: String,
    #[validate(required, min = 1)]
    pub quantity: i64,
}

async fn store(Valid(form): Valid<StoreOrder>) -> Result<Redirect> { … }

class SendInvoice implements ShouldQueue
{
    public $tries = 5;

    public function __construct(public int $orderId) {}

    public function handle(): void
    {
        Mail::to($this->order->email)->send(new Invoice($this->order));
    }
}

SendInvoice::dispatch($order->id);

#[derive(Serialize, Deserialize)]
pub struct SendInvoice { pub order_id: i64 }

impl Job for SendInvoice {
    const NAME: &'static str = "send-invoice";
    const MAX_ATTEMPTS: u32 = 5;

    async fn handle(self, ctx: JobContext) -> Result {
        let order = Order::find_or_404(&ctx.state.db, self.order_id).await?;
        ctx.state.mailer.send(invoice(&order)).await
    }
}

state.queue.dispatch(SendInvoice { order_id: order.id }).await?;

The whole Laravel → Renox guide, from routes to queues, with what is different and why.

005 Benchmarks

All those batteries, a tenth of Laravel's latency.

A real page: 20 rows from SQLite rendered through a template, with every Renox default on (CSP, session, CSRF, auth, locale, error pages). Renox serves 9× Laravel Octane and 16× PHP-FPM, at a tenth of the latency and a tenth of the memory, and keeps about two thirds of bare Axum's throughput.

Measured 2026-10-07 on an Intel i7-6700: each server pinned to 2 cores and 1 GB in Docker, oha with 64 connections for 15 s after a 5 s warm-up. The raw numbers and the bare-route results are in benchmarks/RESULTS.md. How it is measured, and how to run it yourself.

008 How it compares

The productivity of a full-stack framework, the footprint of a library.

009 From the blog

What's new in Renox.

• 2026-10-08Renox 1.0: stable, with a design system and one real exampleRenox 1.0 is on crates.io. The API is stable under semver, the UI kit has a new look and icons, and one complete example explains every page beside its code.
• 2026-10-07How a benchmark made Renox 3.3× fasterMeasuring Renox against bare Axum showed every request cloning a 35-field state tens of times. Making it one Arc tripled throughput.
• 2026-10-07Meet the bike shop: a whole business built with RenoxThree stores that sell, rent and service bikes, with staff roles per store and reports. Renox's flagship example, live and explained.

All posts · Atom feed