Introduction

FORGE is an Application Factory — a CLI tool that generates complete, production-ready full-stack applications from a single command. Unlike traditional scaffolding tools that produce bare-bones boilerplate, FORGE generates fully functional applications with authentication, role-based access control, admin dashboards, content management, multi-language support, and infrastructure configuration already wired together and ready to run.

Why FORGE?

Building a modern full-stack application from scratch means stitching together dozens of libraries, writing repetitive CRUD logic, configuring authentication, setting up infrastructure, and repeating the same patterns across every project. FORGE eliminates this entirely.

With one command, you get a working application that would otherwise take weeks to build:

forge new --name=myapp

This produces a complete application — not just files on disk, but a running system with HTTPS, database migrations, seeded data, and a default admin account ready to log in.

FORGE generates applications, not boilerplate

Every generated project includes working authentication, admin CRUD, API documentation, content management, navigation menus, audit logging, and more. You start building your business logic on day one.

Technology Stack

FORGE combines best-in-class technologies for each layer of the stack:

Layer	Technology	Why
Backend	Rust + Axum	Memory-safe, blazing fast, async-first
Frontend (Web)	Next.js 14+ (App Router)	SSR, React Server Components, TypeScript
Frontend (Admin)	Next.js 14+ (App Router)	Separate admin app with shadcn/ui components
Database	PostgreSQL 15+	JSONB translations, full-text search, robust
Cache	Redis 7+	Session store, rate limiting, caching
Reverse Proxy	Caddy	Automatic HTTPS, zero-config SSL
Containers	Docker + Docker Compose	Reproducible development and deployment
Styling	Tailwind CSS + shadcn/ui	Utility-first with accessible components
Forms	React Hook Form + Zod	Type-safe validation
State	TanStack Query	Server state management with caching
Icons	Lucide React	Consistent, tree-shakeable icon set

Core Philosophy

Contract-First Design

FORGE is built on a contract-first architecture. Every backend, frontend, provider, and template module implements a well-defined contract (interface). This means:

• Backends are interchangeable — Rust today, Laravel or FastAPI tomorrow. The API contract stays the same.
• Frontends are interchangeable — Next.js today, Nuxt.js or Angular tomorrow. The page and component contracts stay the same.
• Providers are pluggable — Swap Twilio for Vonage, or AWS S3 for MinIO, without changing application code.

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   Backend    │     │   Frontend   │     │   Provider   │
│   Contract   │     │   Contract   │     │   Contract   │
├──────────────┤     ├──────────────┤     ├──────────────┤
│ • Rust/Axum  │     │ • Next.js    │     │ • Twilio     │
│ • Laravel    │     │ • Nuxt.js    │     │ • Vonage     │
│ • FastAPI    │     │ • Angular    │     │ • AWS S3     │
│ • Node.js    │     │ • Vanilla    │     │ • MinIO      │
└──────────────┘     └──────────────┘     └──────────────┘

Template Extensibility

The base template includes everything you need for a standard application: users, roles, permissions, authentication, content management, navigation menus, media uploads, and more. Additional templates layer on top to add domain-specific features:

• CRM — Contacts, deals, pipelines, activities
• Helpdesk — Tickets, SLAs, knowledge base
• Invoicing — Invoices, payments, tax management

Each template adds its own models, migrations, API endpoints, admin pages, and web pages — all following the same contracts.

Tera Templating Engine

FORGE uses the Tera templating engine to generate source code. Every file in the output project is rendered from a .tera template, with access to your project configuration (name, languages, auth method, providers, and more). This makes the generated code clean and idiomatic — not littered with conditionals or unused code paths.

What You Get

A generated FORGE application includes:

• Authentication — JWT with refresh tokens, login, registration, password reset, optional OTP
• Role-Based Access Control — Granular permissions, role assignment, middleware enforcement
• Admin Dashboard — User management, role management, content editor, media library, audit logs
• Web Application — Public pages, user profile, dynamic navigation, language switching
• Content Management — Rich text pages with translatable content, slug-based routing
• Menu System — Dynamic navigation menus manageable from the admin panel
• Media Management — Polymorphic file uploads with image processing
• Lookup Tables — Configurable key-value tables for dropdowns and reference data
• Multi-Language — JSONB-based translations, RTL support, per-request locale detection
• API Documentation — Auto-generated OpenAPI spec with Swagger UI and ReDoc
• Infrastructure — Docker Compose, Caddy reverse proxy, local SSL certificates
• Database — Versioned migrations, seeders with default data, proper indexing

Every feature is fully integrated

Authentication flows into RBAC, which gates admin pages, which manage content and menus, which render on the web app — with multi-language support at every layer. Nothing is left as a stub or TODO.

Next Steps

Ready to get started? Follow the guides in order:

• Installation — Install prerequisites and the FORGE CLI
• Quick Start — Create and run your first application
• Configuration — Understand and customize forge.yaml
• Directory Structure — Learn how the generated project is organized