Documentation README
Français English

Runique — l'expérience développeur Django, en Rust type-safe

Rust Tests passing License Version Crates.io GitHub stars Runique

Déclarez un modèle une fois, et vous récupérez la table en base, la migration, un formulaire type-safe et un panel admin complet — sans câblage supplémentaire. Runique apporte la productivité de Django à Rust sans vous demander de renoncer à sa sécurité ni à ses performances. Construit sur Axum, SeaORM et Tera, il s'efface une fois le code répétitif écarté.

Statut, sans détour : développement actif. Le crate du framework (runique) fait foi ; demo-app est une vraie application testée contre lui, pas une démo jetable. Le panel admin est en bêta. Rien ci-dessous n'est enjolivé — voir l'état du projet pour la version sans filtre.

🌍 Langues : English | Français

Des macros déclaratives, pas du code répétitif

model! {
    Article,
    table: "articles",
    pk: id => Pk,
    enums: { Status: [Draft="Draft", Published="Published"], },
    {
        title:  text [required],
        slug:   text [unique],
        body:   richtext [required],
        status: choice [enum(Status), default: "Draft"],
        views:  int [default: 0],
    }
}

model! génère l'entité SeaORM (article::Model) et sa migration SQL (runique makemigrations) à partir de la même déclaration. Ajoutez #[form] et vous obtenez un formulaire type-safe correspondant, validé côté serveur et dérivable directement du schéma. Enregistrez la ressource dans admin! et le CRUD est déjà là — liste, recherche, filtres, permissions, tout y est :

admin! {
    article: article::Model => ArticleForm {
        title: "Articles",
        list_display: [["title", "Title"], ["status", "Status"], ["views", "Views"]],
        list_filter:   [["status", "Status", 5]],
    }
}

Pourquoi Runique

Rust a déjà de bonnes briques web, rapides et bas niveau — ce qui lui manque, c'est un framework offrant d'entrée la productivité quotidienne de Django. Assembler soi-même un ORM, un moteur de templates, une couche de formulaires et un admin est un projet à part entière avant même d'avoir écrit une seule fonctionnalité. Runique fait ce câblage à votre place, selon un jeu de conventions cohérent, pour que le temps aille dans votre application plutôt que dans sa plomberie — sans rien perdre de la sécurité des types ni des performances de Rust.

Django (Python)Runique (Rust)
models.pymodel! → entité SeaORM + migration
forms.py#[form] formulaires type-safe
admin.pyadmin! panel admin généré
urls.pyurlpatterns! macro de routing
Templates DjangoTera (auto-échappé)
QuerySetSeaORM + DSL de requêtes search!
middlewareslots de middleware ordonnés

Pour le tableau complet : Runique vs Django.

Sécurité par défaut

Rien de tout ça n'est ajouté après coup — c'est la base dont vous partez :

Politique de sécurité

Démarrage rapide

runique new myapp
cd myapp
cargo run            # votre app est un binaire Rust normal

runique start régénère le code CRUD admin depuis vos déclarations admin!, puis lance cargo run lui-même — une étape de génération one-shot enchaînée au lancement, pas un watcher en tâche de fond (voir Admin (bêta)). Un simple cargo run saute la régénération.

Un main.rs allégé (version complète dans demo-app/src/main.rs) :

use runique::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = RuniqueConfig::from_env();
    let db = DatabaseConfig::from_env()?.build().connect().await?;

    RuniqueApp::builder(config)
        .routes(url::routes())
        .with_database(db)
        .statics()
        .build()
        .await
        .map_err(|e| -> Box<dyn std::error::Error> { Box::new(e) })?
        .run()
        .await?;
    Ok(())
}

Les routes passent par la macro urlpatterns! et ressortent sous forme d'un Router Axum classique :

pub fn routes() -> Router {
    urlpatterns! {
        "/"          => view!{ index },        name = "index",
        "/blog/{id}" => view!{ blog_detail },  name = "blog_detail",
    }
    .rate_limit("/login", "login", view!(login_user), 10, 60, vec![Method::POST])
}

Pour le guide complet : Installation

Contenu de ce dépôt

Version du workspace (source de vérité) : 3.0.3.

CLI

runique fournit :

Admin (bêta)

runique start fait trois choses, dans l'ordre, sur un seul thread :

  1. il parse vos déclarations admin! dans src/admin.rs
  2. il génère le code CRUD sous src/admins/
  3. il lance cargo run --release, bloquant

Il vérifie d'abord si .with_admin(...) existe dans src/main.rs, et ne génère/lance que si c'est le cas — sinon il quitte avec un message expliquant pourquoi. Pas de surveillance continue : relancez runique start pour régénérer après une modification de src/admin.rs.

C'est encore de la bêta : les permissions fonctionnent surtout au niveau des ressources pour l'instant, le dossier généré src/admins/ est écrasé à chaque régénération, et le durcissement est en cours plutôt que terminé.

Documentation admin : Admin

Features et bases de données

Activée par défaut : orm, qui apporte SeaORM (entités, requêtes, migrations, sessions) mais aucun pilote de base de données : un build avec orm seul compile, et makemigrations fonctionne, mais l'application ne peut se connecter à rien.

Choisir explicitement un seul backend : sqlite, postgres, mysql, mariadb (mutuellement exclusifs — en activer deux à la fois est une erreur de compilation). Chacun active aussi orm : features = ["postgres"] suffit. La feature all-databases reste disponible pour le tooling multi-moteur qui doit parler à tous les backends à la fois.

Sessions

CleaningMemoryStore remplace le MemoryStore par défaut : il ajoute un nettoyage automatique des sessions expirées, un système de double watermark (128 Mo / 256 Mo) pour borner la mémoire, et une priorité pour les sessions authentifiées — elles sont purgées en dernier sous pression, et survivent aux redémarrages grâce à un fallback en base.

Référence complète : Sessions

Tests et couverture

cargo llvm-cov --package runique --features all-databases --summary-only

Détail complet par fichier : docs/couverture_test.md

Documentation

État du projet & ressources

Licence

MIT — voir LICENSE