80% less code. 100% type safety. Production-ready performance. Built for humans and AI agents alike.
Developer Experience
AI Experience
#[elif::bootstrap]
fn main() {
// That's it. Server configured and running.
}#[controller("/api")]
impl UserAPI {
#[post("/users")]
#[body(user: CreateUser)]
async fn create(&self, user: CreateUser) -> ElifResponse {
let user = self.service.create(user).await?;
ElifResponse::created().json(&user)
}
}#[elif::bootstrap]
The Laravel moment for Rust.
// Define your module
#[module(
controllers: [UserController, PostController],
providers: [UserService, EmailService],
is_app
)]
struct AppModule;
// Bootstrap magic - everything configured
#[elif::bootstrap(AppModule)]
async fn main() -> Result<(), HttpError> {
// ✅ Dependency injection configured
// ✅ Routes registered automatically
// ✅ Middleware pipeline ready
// ✅ Server running on :3000
}// Manual setup eliminated:
// ❌ No tokio::main boilerplate
// ❌ No manual DI container
// ❌ No route registration
// ❌ No server configuration
// ❌ No middleware setup
// ❌ No error handling wrapper$ cargo install elifrs
Install the CLI
$ elifrs new my-api
Create your project
$ cd my-api && cargo run
Your API is live!
Where AI meets human intuition.
Built for the next generation of development.
200k+ requests/sec. Zero runtime overhead.
Claude, GPT-4, Cursor, Copilot understand naturally.
Millions of concurrent connections. Modular by design.
Memory safety. OWASP compliant.
One macro configures everything. Laravel-level DX.
APIs designed for LLM understanding from day one.
200k req/sec with zero-boilerplate setup.
One macro. Zero boilerplate.
The Laravel/NestJS moment for Rust.
#[controller("/api/users")]
impl UserController {
#[post("")]
#[body(user: CreateUserRequest)]
async fn create(&self, user: CreateUserRequest) -> ElifResponse {
// Direct access to typed body
let new_user = self.service.create(user).await?;
ElifResponse::created().json(&new_user)
}
#[put("/{id}")]
#[param(id: i32)]
#[body(data: UpdateUserRequest)]
async fn update(&self, id: i32, data: UpdateUserRequest) -> ElifResponse {
// Parameters automatically injected
let user = self.service.update(id, data).await?;
ElifResponse::ok().json(&user)
}
}// New helper methods
req.path_param_as::<i32>("id")?
req.query_param_as::<bool>("active")?
req.bearer_token()?
req.json_async::<User>().await?impl Middleware for Auth {
fn handle(&self, req: ElifRequest, next: Next) -> NextFuture {
Box::pin(async move {
if !authenticated(&req) {
return ElifResponse::unauthorized();
}
next.run(req).await
})
}
}// Traditional Rust: 15-20 lines of setup
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
env_logger::init();
dotenv::dotenv().ok();
let db = Database::connect(&env::var("DATABASE_URL")?)?;
run_migrations(&db).await?;
let config = Config::from_env()?;
let app_state = AppState::new(db, config);
let app = Router::new()
.merge(user_routes())
.merge(auth_routes())
.layer(cors_layer())
.layer(trace_layer())
.with_state(app_state);
let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
axum::Server::bind(&addr)
.serve(app.into_make_service())
.await?;
Ok(())
}// elif.rs: 3 lines. Everything configured.
#[elif::bootstrap]
fn main() {
// Database, migrations, logging, tracing, CORS, server - all ready.
}// Manual parameter extraction
async fn update_user(
Path(id): Path<i32>,
State(state): State<AppState>,
Json(payload): Json<UpdateUser>
) -> Result<impl IntoResponse, AppError> {
// Manual auth check
let token = extract_bearer_token(&req)?;
let claims = verify_token(&token)?;
// Service call
let user = state.service
.update_user(id, payload)
.await?;
Ok(Json(user))
}// Everything auto-injected
#[put("/{id}")]
#[param(id: i32)]
#[body(data: UpdateUser)]
async fn update(&self, id: i32, data: UpdateUser) -> ElifResponse {
let user = self.service.update(id, data).await?;
ElifResponse::ok().json(&user)
}#[elif::bootstrap]
fn main() {}
#[controller("/api")]
impl ApiController {
#[get("/health")]
async fn health(&self) -> ElifResponse {
ElifResponse::ok().json(&json!({ "status": "healthy" }))
}
}async fn handler(req: &ElifRequest) {
let user = req.json_async::<User>().await?
ElifResponse::ok().json(&user)
}let users = User::query()
.where_email_like("%@domain.com")
.limit(10)
.get().await?;Rust that reads like poetry.
Write with intention. Code with clarity.
// Traditional: Manual route registration
let app = Router::new()
.route("/api/users", get(list_users))
.route("/api/users", post(create_user))
.route("/api/users/:id", get(get_user))
.route("/api/users/:id", put(update_user))
.route("/api/users/:id", delete(delete_user))
.layer(cors_layer())
.layer(auth_layer());// Convention over configuration
#[controller("/api/users")]
#[middleware(cors, auth)]
impl UserController {
// All routes auto-generated
}// Extracting request data manually
let id = req.param("id")
.ok_or_else(|| Error::MissingParam)?
.parse::<i32>()
.map_err(|_| Error::InvalidParam)?;
let query = req.uri().query()
.ok_or_else(|| Error::MissingQuery)?;
let params = parse_query(query)?;
let active = params.get("active")
.map(|v| v == "true")
.unwrap_or(false);// Direct, type-safe access
let id = req.path_param_as::<i32>("id")?;
let active = req.query_param_as::<bool>("active")?;A complete ecosystem designed for modern development
Zero-boilerplate CLI with #[elif::bootstrap] magic.
elif-http
HTTP server & routing
elif-orm
Database ORM
elif-auth
Authentication
elif-validation
Input validation
elif-openapi
Auto API docs
elif-testing
Test utilities
elif-security
Security middleware
elif-cache
Caching system
elif-core
Foundation
Core framework architecture
elif-http
Essential
Web server & WebSockets
elif-queue
Production
Background job processing
elif-middleware
V2
Composable middleware
Join the community building with both human and AI intelligence