Built in Rust — the systems programming language
A Rust-first foundation for serious business software.
Written in Rust — the language built for speed and memory safety — RustIO is a business-system engine that stays fast, safe, and auditable as a business grows, exactly where admin screens and conventional web stacks give out.
The problem is not always bad developers. It's often a weak system foundation.
RustIO was born from a real market problem, not a wish to build another admin panel. A fast-growing housing platform in the Swedish market — serving a very large customer base — began to crack under its own success.
Not because of its engineers, but because the foundation was never designed to be a heavy-duty operational engine. As data grows and pressure rises, conventional stacks show their limits: slower performance, climbing cost, fragile changes, constant firefighting.
That story isn't unique — it's the industry default. Teams rebuild the same foundation, hit the same wall, firefight the same failures. RustIO exists for exactly that moment — when a business outgrows its first system and needs a foundation that won't collapse under its own growth.
You describe the system. RustIO makes it safe to run.
A deliberately simple path — with a human review gate before anything becomes real.
Business idea
You describe the system you need in plain business terms.
rustio-draft
The companion drafts a schema.json from your intent.
Safe schema
Validated against strict, checked-in rules before it lands.
rustio-admin
Import, plan, review, commit — a human approves the change.
Operational system
A foundation you keep evolving safely for years.
AI drafts. RustIO validates. Diff protects. Human approves.
A system engine for operational software.
Most admin tools treat CRUD as the product and bolt on auth, recovery and audit afterward. RustIO inverts that — authority is designed as one system, governed by checked-in contract documents. The CRUD is the easy layer on top.
Authority, sessions, recovery and audit — engineered as one system.
The weight of production administrative work sits underneath the CRUD surface. RustIO treats it as first-class, not an afterthought.
Admin surface
#[derive(RustioAdmin)] generates list, create, edit and delete pages. impl ModelAdmin overrides the defaults. Per-model RBAC over a five-tier role hierarchy.
Identity & sessions
DB-backed sessions with Argon2id passwords, hashed-at-rest tokens, and centralised invalidation. Doctrine 22: session invalidation has a single writer.
Recovery
Self-service forgot & reset, admin-driven reset/lock/unlock/revoke, auto-throttle on failed logins, and a re-auth wall for destructive actions.
Audit by default
Every authority mutation emits a typed AuditEvent with stable identifiers, per-request correlation IDs, and redaction helpers for tokens and passwords.
AI assistant permissions
rustio ai governs what an external AI coding assistant may do — an approval & audit layer, not an embedded model. Every capability sorted Allowed / Needs approval / Blocked.
Project memory
rustio memory records the why behind a project — decisions, rejected ideas, assumptions — so an AI or a new teammate reads years of reasoning in minutes. Code always wins.
Session invalidation has a single writer.
Recovery and login surfaces collapse every failure mode into one response shape.
Every authority mutation emits a typed AuditEvent.
Argon2id for passwords. SHA-256 for session and reset tokens.
An admin surface is one derive, one impl, one register call.
#[derive(RustioAdmin)] pub struct Post { pub id: i64, pub title: String, /* … */ } impl Model for Post { /* TABLE, COLUMNS, from_row, insert_values */ } impl ModelAdmin for Post {} // accept every default let admin = Admin::new().model::<Post>(); let router = register_admin_routes(Router::new(), admin, db, templates); Server::new(router, addr).run().await?;
Different sectors, one operational foundation.
These sectors differ, but they share one foundation: data, permissions, workflows, review, reporting, and daily operation. RustIO is the layer they all stand on.
No longer a single repo — a small, disciplined ecosystem.
Four crates ship together; companions and a commercial line surround the open core. Core repos only — no clutter.
Install, generate, review, ship. Postgres only. No frontend build step.
Get running
Add to Cargo.toml: rustio-admin = "0.31.0"
Read & explore
Reference projects: examples/clinic (multi-crate) and examples/shop (single-crate e-commerce admin).
Fund open Rust infrastructure for serious business systems.
RustIO is developed independently — no company, investors, or outside funding. Sponsorship is early backing for open infrastructure, not a personal donation. It keeps the core free and inspectable.
- Documentation, guides, and onboarding for the open core.
- Realistic examples and reference verticals across critical sectors.
- Long-term maintenance of the authority, session, and audit surfaces.
- Schema-driven admin generation and developer experience.
Open core today. Pro and vertical packs later.
A separate commercial layer funds sustained work without gating the core.
The open core
Everything the engine needs, forever inspectable.
- The full rustio-admin engine & CLI
- Authority, sessions, recovery, audit
- Schema-driven admin generation
- Reference examples and docs
The commercial layer
Optional, open-core — never a gate on the core.
- Hosted / managed option
- Vertical packs for specific sectors
- Support & enterprise integrations
- Priority for teams building on RustIO
RustIO is not an admin panel. It's a foundation.
Build systems quickly. Evolve them safely. Stay in control.