Laravel Omega: What We Actually Know About Laravel for Rust

Laravel Omega: What We Actually Know About Laravel for Rust

On Monday, October 5, Taylor Otwell posted three lines of code and nothing else:

use laravel::{Application, inertia};

use crate::http::middleware::HandleInertiaRequests;
use crate::routes;

No caption. No link. Just Rust, typed in that monospace Unicode font people use when they want a tweet to look like a terminal. It got 85k views and 680+ likes in a day, and the replies filled up with one word: Omega.

I write Laravel for a living. I have never written a line of Rust. So this post is a Laravel developer reading Rust for the first time, which is probably exactly who Omega is for. None of the Rust code below is mine: it is quoted from Taylor's post and from the public repo, with links. I zoomed into those three lines like everyone else, then went looking for anything solid. This post is what I found, sorted into "confirmed", "very likely" and "people are guessing".

Short version: there is no Omega release, no docs, no landing page. But there is a public repository under the Inertia.js organisation, with Taylor's name on the commits, and it tells us a lot.

The timeline

Everything public so far, in order. All times UTC.

Notice the first two rows on October 5. The repo went up about two hours before the tweet. That is not a coincidence I am willing to ignore.

A licence plate that says FACADE, posted on the same day as a Rust teaser, captioned "Rust meet-up". If you know Laravel, you know what a facade is. I don't think Taylor picked that photo at random.

Reading the three lines like a Laravel dev

Each line in that snippet maps to something you already have in a Laravel app.

use laravel::{Application, inertia}; A crate literally named laravel. Application is the same name as Illuminate\Foundation\Application, the container that boots everything. And inertia is exported from the framework itself, not pulled in as a third-party package. That tells me Inertia is a first-class citizen, like it is in the official starter kits.

use crate::http::middleware::HandleInertiaRequests; In Rust, crate:: means "this project". So the user's app has a folder http/middleware/ with a file defining HandleInertiaRequests. That is app/Http/Middleware/HandleInertiaRequests.php, the exact file every Laravel + Inertia app has. The folder structure survived the language change.

use crate::routes; A routes module in the app. Same idea as routes/web.php.

So the shape is: a Laravel skeleton, in Rust, where your app code lives in your crate and the framework lives in laravel. That is the confirmed part, and it is already more than I expected.

The repo that isn't a rumour: inertia-omega

inertiajs/inertia-omega is public, MIT, marked ALPHA, and at the time of writing has 9 commits and around 110 stars. Its description: "The Inertia.js server-side protocol for Rust, with a framework-agnostic core and an Axum adapter."

A few details that matter:

• It is called inertia-omega, but you import it as inertia. The Cargo.toml sets [lib] name = "inertia". The README links to a laravel/omega-workspace repo for setup. That repo returns a 404 for me, so it is private. There is the "Omega" name, on an official org, pointing at a private Laravel workspace.
• It mentions a sibling crate called laravel-omega-vite, which renders asset tags "like Laravel's @vite". Also not public yet.
• Taylor is a contributor. Recent commits carry Co-authored-by: Taylor Otwell <taylor@laravel.com>.
• It is a port, not a rewrite from scratch. The README says the props resolver and the protocol rules are ports of inertia-laravel, and credits Veer for the adapter design.
• It is built heavily with AI agents. Commits carry Amp thread IDs and the first commit is co-authored by Claude. Make of that what you will. I find it interesting that the creator of one of the biggest PHP frameworks is porting it with agents doing a lot of the typing.

What the code looks like

A handler, straight from the README:

async fn show(inertia: Inertia, Path(id): Path<u64>, State(db): State<Db>) -> inertia::Response {
    let user = db.find_user(id).await;

    inertia.render("Users/Show", props! {
        "user" => user,
        "activity" => inertia::defer(move || async move { db.activity_for(id).await }),
    })
}

If you have written Inertia::render('Users/Show', [...]) with an Inertia::defer() prop, you can read that without knowing any Rust. That is clearly the point.

Validation and redirects feel familiar too:

async fn store(inertia: Inertia, Json(form): Json<NewUser>) -> HttpResponse {
    let mut errors = ValidationErrors::new();

    if form.name.trim().is_empty() {
        errors.add("name", "The name field is required.");
    }

    if !errors.is_empty() {
        return inertia.back_with_errors(errors);
    }

    create_user(form).await;
    inertia.flash("toast", "User created!");

    inertia::redirect("/users")
}

Yes, that error message is word for word Laravel's validation.required string.

And testing, modelled on assertInertia:

AssertablePage::from_body(&body)
    .component("Users/Index")
    .has_count("users", 3)
    .equals("users.0.name", "Taylor")
    .missing("users.0.password")
    .deferred("default", &["stats"])
    .flash("toast", "Saved!");

The cheat sheet they wrote for us

The README has a "Coming from Laravel" table. Here is a trimmed version, because it is the best preview of how Omega wants to feel:

Not ported yet, per the README: Inertia DevTools, ProvidesInertiaProperties, component name transformers, the ensure_pages_exist check, and Precognition.

Under the hood

Today the adapter targets Axum with tower-sessions. Feature flags let you turn pieces on and off:

It needs Rust 1.99 and the 2024 edition. SSR works the way it does in Laravel: a public/hot file in development, bootstrap/ssr/app.js in production. Those paths are Laravel paths. Again, not an accident.

Confirmed, likely, guessing

Let me be careful here, because a lot of posts this week blurred the line.

Confirmed

• Taylor is writing Rust that imports from a crate called laravel, with Laravel's folder conventions.
• A public, alpha, Laravel-team-backed Inertia server adapter for Rust exists and uses the "omega" name.
• A private laravel/omega-workspace and a laravel-omega-vite crate exist (referenced in the README).
• Taylor has used the word "Omega" himself ("Omega before GTA6").

Very likely

• Omega is the codename for a Laravel-style framework in Rust, and inertia-omega is the first piece shipped in public.
• Inertia + React/Vue/Svelte is the default frontend story, like the current starter kits.
• It sits on Axum and Tokio rather than building its own HTTP server, at least for now.

People are guessing

• That Omega replaces PHP Laravel. Nothing says that. Laravel 13.x shipped point releases the same week.
• A release date. "Before GTA6" is a joke, and GTA6 keeps moving anyway.
• Eloquent, queues, Blade, Artisan in Rust. Probably on the list, zero public evidence yet.
• One reply guessed it is a PHP-to-binary compiler written in Rust. The use crate::http::… line is app code written in Rust, so I don't buy it.

The other "Laravel for Rust" projects

Omega is not the first attempt. The community has been building this for a while, and if you want to play with the idea today, these exist:

There is also a candid DEV post, "I built a Laravel-like web framework for Rust, but nobody is using it yet", which is worth reading because it shows the real problem. The code is not the hard part. Docs, ecosystem and trust are. That is exactly the thing Laravel the company has and these projects do not.

Why would anyone want this?

My take, as someone who ships Laravel and has not shipped Rust. Take the Rust side with that in mind:

What Rust would buy you. One binary you scp to a server. No PHP-FPM, no OPcache tuning, no "which extension is missing on prod". Type errors at compile time instead of in Sentry at 2 a.m. Long-running processes that don't need Octane tricks to stay warm. Those are the reasons Rust people give.

What it would cost you. A new language for most of us, with compile times and a borrow checker that Rust developers themselves warn newcomers about. And the biggest one, which I can judge from the Laravel side: Laravel's magic is mostly runtime magic. Facades, the container, Eloquent's __call, macros. Rust doesn't do runtime magic. You get macros and traits instead. Looking at props! and the Inertia extractor, the team seems to be translating the feel rather than the mechanism, and I think that is the right call.

What I am watching for.

1. An ORM. This is where Rust frameworks live or die. Eloquent is the reason half of us stay.
2. Whether php artisan make:* becomes cargo laravel make:* or something new.
3. How Forge, Vapor and Laravel Cloud treat a Rust app. Cloud deploying a single binary would be a big deal.
4. Whether the Filament and Livewire world gets a story at all, or whether Omega is Inertia-only.

How to follow along

• Watch inertiajs/inertia-omega on GitHub. It is the only public code, and it moves every few days.
• Follow @taylorotwell on X. Every clue so far came from there.
• Keep an eye on laravel-news.com and the Laravel Daily newsletter.
• If you want to try the protocol now, clone inertia-omega, run cargo test --all-features, and read tests/core.rs. It is the clearest view of how the core works without a web framework.

I will update this post when there is an official announcement. If you spot something I missed, a reply, a repo, a talk, send it to me and I'll add it with credit.

Sources

• Taylor Otwell, use laravel::{Application, inertia};, Oct 5, 2026
• Punyapal Shah, "Omega: Laravel for Rust", Oct 5, 2026
• Taylor Otwell, "Ready for the Rust meet-up", Oct 5, 2026
• Taylor Otwell, "Omega before GTA6", Oct 7, 2026
• Taylor Otwell, "from @laravelphp to @laravel", Jul 16, 2026
• inertiajs/inertia-omega README, Cargo.toml and commit history
• inertiajs/inertia-laravel, the adapter it ports
• Inertia v3 protocol
• Laravel Daily, "The Future of Laravel is... Rust?", Oct 8, 2026