Inertia RustReact pages. A Rust server. No API.

A controller and the page it renders ​

The controller loads the data and hands it to a React page as props. There's no JSON API in between, and nothing to keep in sync.

// src/controllers/projects.rs
async fn index(
    current: CurrentAccount,
    State(ctx): State<AppContext>,
    inertia: Inertia,
) -> Result<Response> {
    let projects: Vec<Value> = projects::Model::list(&ctx.db, current.account.id)
        .await?
        .iter()
        .map(projects::Model::to_props)
        .collect();
    render(inertia, "projects/index", json!({ "projects": projects })).await
}

// frontend/pages/projects/index.tsx
import { Link } from "@inertiajs/react"

import { useCurrentAccount } from "@/hooks/use-current-account"
import { projects as routes } from "@/routes"

interface Project {
  id: number
  name: string
}

export default function Projects({ projects }: { projects: Project[] }) {
  const { slug: accountSlug } = useCurrentAccount()

  return (
    <ul>
      {projects.map((project) => (
        <li key={project.id}>
          <Link href={routes.show({ accountSlug, id: project.id })}>
            {project.name}
          </Link>
        </li>
      ))}
    </ul>
  )
}

cargo loco generate scaffold projects name:string! writes both, plus the model, migration, routes and tests.

The Inertia way ​

Coming from Rails? The kit follows the Inertia Rails React Starter Kit, and Rails → Loco maps each rails command to its equivalent here.

The numbers ​

Both kits as production Docker images on the same workstation, 4 pinned CPUs each, SQLite, SSR off, Rails with YJIT and Puma 4×3. Medians of 5 runs, 2026-10-04.

The caveats are real. Under a 4 GB container limit, 0.17% of SQLite writes from 32 writers failed with a 500 (pool timeouts during write stalls; none with 32 GB), where Rails had none. With SSR on, Node is the bottleneck and throughput is about equal. The Rails kit builds its image faster from cold and reloads code instantly. Method, ranges and every caveat: the full benchmark.

Get started ​

Click Use this template on GitHub, or clone it. You need Rust (rustup) and Node 22.

git clone https://github.com/cole-robertson/inertia-rust-starter-kit.git myapp
cd myapp
bin/rename my_app "My App"   # optional, but do it before the first bin/setup (see below)
bin/setup                    # npm ci, cargo build, migrate, seed, then bin/dev

Open http://localhost:5150 and sign in as one@example.com / Secret1*3*5*. Then build your app: rename it, scaffold a resource, add jobs and mail, deploy.

FAQ ​

Why Rust? ​

For one small binary that boots in milliseconds, uses a fraction of the memory and serves more requests per core, with the compiler checking the server code and typed routes shared with React. Loco brings Rails' shape to Rust: generators, migrations, jobs, mailers, tasks. The trade is slower builds and no autoloading; see the benchmark for both sides.

Where does it come from? ​

It started as a port of the Inertia Rails React Starter Kit, and it still matches its routes, pages and messages, checked by a test that compares both kits' responses. Organizations are added on top. Every intended difference is listed in Parity with the Rails kit.

Can I use Postgres? ​

Not out of the box. The kit ships SQLite (WAL mode) for the app and its job queue, and the benchmark, the deploy targets and some code (src/db.rs) assume it. Loco and SeaORM support Postgres, so a switch is possible, but you'd be doing it yourself.

Do I need to know Rust? ​

You'll read and write some. The generators write most of the server code, the pages are plain React and TypeScript, and AGENTS.md plus the kit's skills give a coding agent the exact steps for each task. Rails experience carries over: Rails → Loco.

Is it production-ready? ​

It's v0.1. It has tests (Rust request and protocol tests, Playwright in client- and server-rendered modes), a security review and CI on every change, and the live demo runs it. But it's new, it has few users yet, and SQLite means one app server per database. Read the changelog and judge for yourself.

Why accounts by default? ​

Most business software keeps data per organization, and accounts are cheap to keep but expensive to add to an app that already has data. If your app has no teams, the accounts guide shows how to flatten it.