v1.0.0-beta.8· Python 3.12+· MariaDB· MVC serveur· Disponible sur PyPI

Une forge pour les créer toutes.

Framework web applicatif Python.

Forge permet de créer rapidement des applications web MVC structurées, lisibles et maintenables, avec du SQL visible, des générateurs contrôlés, un front léger et un core pédagogique sans magie cachée.

Découvrir le core Lire la documentation Voir GitHub

workflow Forge 1.0.0-beta.8

$ forge doctor
$ forge make:entity Contact --no-input
# Décrire les champs dans mvc/entities/contact/contact.json
$ forge build:model --dry-run
$ forge build:model
$ forge db:apply
$ forge make:crud Contact

Construire des applications MVC sans perdre la main.

Forge vise les applications de gestion, les back-offices, les sites publics avec administration, les démonstrateurs pédagogiques et les projets où le code généré doit rester compréhensible.

Ce que Forge fait bien

Applications MVC serveur en Python
Back-offices simples à intermédiaires
CRUD généré, lisible et modifiable
Projets pédagogiques et prototypes propres
Applications avec SQL visible et schéma auditable
Sites publics reliés à une administration interne

Ce que Forge ne cherche pas à être

Pas un clone de Django, Symfony, Laravel ou FastAPI
Pas un ORM complet imposé au développeur
Pas une SPA React/Vue/Svelte intégrée au core
Pas une application métier prête à vendre
Pas une boîte noire qui cache routes, SQL ou fichiers générés
Pas une plateforme SaaS multi-tenant prématurée

L'écosystème Forge.

Un core minimal pour bâtir des applications MVC Python, et des modules officiels installables séparément pour les besoins avancés.

Le core Forge

Le cœur du framework fournit les briques génériques. Tout starter Forge n'est qu'un démonstrateur — le moteur reste dans le core.

HTTP & routing

Requêtes, réponses, routes nommées et contrôleurs explicites.

MVC

Structure claire : contrôleurs, modèles, vues, routes et formulaires.

Templates Jinja

Rendu serveur lisible, layouts publics/admin et composants simples.

SQL visible

Fichiers SQL auditable, sans ORM opaque imposé par défaut.

Entités JSON

Une source canonique pour générer SQL, modèles et CRUD.

Migrations

Migrations SQL versionnées, contrôlables et lisibles.

CRUD généré

Back-office explicite, modifiable et non destructif.

Formulaires

Champs typés, validation serveur et messages clairs.

Sécurité

CSRF, sessions, headers HTTP, cookies durcis et audit complet.

Auth/User

Médias

Uploads, images, variantes, galeries et suppression propre.

Mail

Transports interchangeables, templates, rendu et logs.

Front léger

Tailwind officiel, HTMX recommandé, Alpine.js optionnel.

i18n

Traductions simples côté Python et côté Jinja.

CLI Forge

Commandes pour générer, vérifier, initialiser et diagnostiquer.

Déploiement

Nginx, systemd, environnement prod et contrôles de déploiement.

API JSON légère

Endpoints JSON explicites avec auth Bearer, sans transformer Forge en moteur d'API.

Modules officiels opt-in

Distribués séparément sur PyPI. Installer un module se fait via pip install forge-mvc-<module> ou via extras forge-mvc[mfa].

MFA

Authentification multi-facteurs : TOTP, codes de récupération, challenge à la connexion. Module forge-mvc-mfa.

RBAC

Rôles, permissions fines, helpers Jinja et décorateurs @require_permission. Module forge-mvc-rbac.

Workflow

Statuts et transitions applicatives : brouillon → publié → archivé. Module forge-mvc-workflow.

Statistiques

Tracking d'événements applicatifs génériques : page vues, clics, conversions. Module forge-mvc-stats.

La stack Forge.

Forge ne réinvente pas l'écosystème Python. Il s'appuie sur des standards éprouvés.

Python 3.12+

Langage de Forge — typage moderne, performance, async natif.

Documentation

MariaDB 11.x

Moteur SQL relationnel, schéma auditable, performant.

Documentation

Jinja2 3.1.6

Templating serveur intégré au core — rendu lisible, layouts publics et admin.

Documentation

HTMX latest

Interactivité progressive HTML-driven — recommandé pour les apps Forge.

Documentation

Alpine.js latest

Réactivité ultra-légère côté client — optionnel.

Documentation

Tailwind latest

Système d'utilities CSS — front officiel.

Documentation

Générer sans masquer.

Forge automatise les répétitions, mais les fichiers restent visibles, auditables et modifiables.

Chaîne de génération

1. JSON d'entité canonique

2. SQL visible et migrations

3. modèle *_base.py régénérable

4. modèle manuel préservé

5. contrôleur, formulaire et vues CRUD

6. application MVC maintenable

$ forge doctor
$ forge make:entity Contact --no-input
$ forge build:model --dry-run
$ forge build:model
$ forge db:apply
$ forge make:crud Contact

{
  "format_version": 1,
  "entity": "Contact",
  "table": "contact",
  "fields": [
    { "name": "id", "sql_type": "INT", "primary_key": true },
    { "name": "nom", "sql_type": "VARCHAR(80)" },
    { "name": "email", "sql_type": "VARCHAR(120)" }
  ]
}

$ forge build:model --dry-run

[ÉCRIT]     mvc/entities/contact/contact.sql
[ÉCRIT]     mvc/entities/contact/contact_base.py
[PRÉSERVÉ]  mvc/entities/contact/contact.py

[DRY-RUN]   Aucun fichier modifié.

Installer Forge selon votre usage.

Deux parcours séparés : utiliser Forge pour créer une application, ou travailler sur le framework lui-même.

Créer une application avec Forge

Parcours utilisateur du framework

Pour installer la commande Forge, créer un projet et lancer le serveur de développement.

$ pipx install --pip-args="--pre" forge-mvc
$ forge new MonApplication
$ cd MonApplication
$ forge doctor
$ python app.py

Forge 1.0.0-beta.8 est une préversion — --pip-args="--pre" est requis. Les modules opt-in s'installent depuis GitHub via requirements-dev.txt.

Guide installation

Contribuer au framework Forge

Parcours développement du core

Pour cloner le dépôt, installer l'environnement de développement et lancer les validations.

$ git clone https://github.com/caucrogeGit/Forge.git
$ cd Forge
$ python -m venv .venv
$ source .venv/bin/activate
$ pip install -e .
$ pytest
$ mkdocs build --strict

Guide développement

Pour la production, le déploiement est traité séparément : Nginx, systemd, variables d'environnement, HTTPS et contrôles avec forge deploy:check. Voir le guide de déploiement. Sur Windows, la voie recommandée est WSL2. Guide Windows (WSL2).

Starters et démonstrateurs.

Les starters prouvent les capacités du framework. Ils ne remplacent pas le core et ne dictent pas l'architecture métier.

Niveau 1

Contacts

Cycle complet d'un CRUD sur une entité : JSON, SQL, formulaire, contrôleur et vues.

Niveau 2

Utilisateurs et authentification

Application de démonstration autour des sessions, du login/logout et des routes protégées.

Niveau 3

Carnet relationnel

Relations explicites, clés étrangères, tables pivots visibles et requêtes SQL lisibles.

Niveau 4

Suivi pédagogique

Démonstrateur plus dense : dashboard, relations, sécurité applicative et données métier.

État actuel

Forge 1.0.0-beta.8

Forge marque l'ouverture du code source en lecture, étude et usage éducatif. Core minimal (HTTP, routing, sessions, templating, SQL visible, formulaires, CRUD), 4 modules officiels installables séparément (MFA, RBAC, Workflow, Stats), charte philosophique stable et 41 tickets livrés pendant la refonte.

Lire la roadmap →

Après 3.0

Stabilisation

Stabilisation continue, raffinements de packaging (src layout standard), consolidation des APIs modules. Forge reste un framework explicite, pédagogique et durable.

Voir la roadmap →

Documentation, guides et code source.

Forge est fortement documenté : tutoriels, guides de modules, référence CLI, sécurité production, politique de release et guide de contribution.

Tutoriel 15 min Application complète Référence API & CLI API JSON légère Sécurité production Release & compatibilité Contribuer Charte GitHub

Plus de 9000 tests — unitaires, documentaires, E2E, sécurité et MariaDB opt-in.