Andurel is a comprehensive web development framework for Go. It prioritizes development speed. Inspired by Ruby on Rails, it uses just enough conventions to let you build full-stack web applications incredibly fast.

Join the discord here

Andurel currently supports Linux and macOS only. Windows is not supported at this time.

If you'd like to help bring Windows support to Andurel, please see issue #382 - contributions are welcome!

Development speed is everything. Andurel eliminates boilerplate and lets you focus on building features:

• Instant Scaffolding - Generate complete CRUD resources with one command
• Live Reload - Hot reloading for Go, templates, and CSS with andurel run powered by Shadowfax
• Type Safety Everywhere - SQLC for SQL, Templ for HTML, Go for logic
• Batteries Included - Echo, Datastar, background jobs, sessions, CSRF protection, telemetry, email support, authentication, optional extensions (workflows, docker, aws-ses)
• Just enough Convention - Convention over configuration is great to a certain point. Andurel provides just enough sensible defaults that just work and get out of your way.
• PostgreSQL-Backed - Built on PostgreSQL with River job queues, pgx driver, and UUID support

The core philosophy around resource generation in andurel, is that it should be a one-time operation that creates everything you need for a fully functional CRUD interface. After that, you can modify and extend the generated code as needed but it's yours to manage going forward.

• Echo - High-performance HTTP framework
• Tailwind CSS - Utility-first CSS framework
• SQLC - Type-safe SQL code generation
• Templ - Type-safe HTML templates
• Datastar - Hypermedia-driven frontend interactivity
• River - PostgreSQL-backed background jobs and workflows
• OpenTelemetry - Built-in observability
• PostgreSQL - Powerful open-source database with pgx driver and native UUID support
• Shadowfax - Andurel specific app runner

This is subject to change as Andurel is in beta.

I have not documented every feature or command yet, only enough to get you started and trying out the framework.

Once the framework reaches a release candidate, I will provide more comprehensive documentation and guides.

go install github.com/mbvlabs/andurel@v1.0.0-beta.3

Andurel gives you choices when creating a new project:

Note: --css vanilla is currently WIP and not properly supported before v1.0.0. Use Tailwind for now.

# Create a new project with defaults (PostgreSQL + Tailwind CSS)
andurel new myapp

# Add extensions for additional features:
andurel new myapp -e docker              # Add Dockerfile for containerization
andurel new myapp -e aws-ses             # Add AWS SES email integration

cd myapp

# Sync tools
andurel tool sync

# Configure environment
cp .env.example .env

# Note: you need to edit .env with your database details

# Apply database migrations
andurel database migrate up

# Run the development server (with live reload)
andurel run

Your app is now running on http://localhost:8080

Andurel provides commands to manage your database lifecycle:

# Create the configured database
andurel database create                    # Requires .env to be filled out with DB credentials

# Drop the configured database (prompts for confirmation)
andurel database drop
andurel database drop --force              # Allow dropping system databases

# Drop and recreate the database
andurel database nuke
andurel database nuke --force              # Allow nuking system databases

# Full rebuild: drop, recreate, migrate, and seed
andurel database rebuild
andurel database rebuild --force           # Allow rebuilding system databases
andurel database rebuild --skip-seed       # Skip seeding after migrations

# Create a migration and add the columns you need. Resource generation requires
# an `id` primary key (uuid/serial/bigserial/string-supported types). `created_at`
# and `updated_at` are optional but recommended.
andurel database migrate new create_products_table

# Create a complete resource with model, controller, views, and routes
andurel generate scaffold Product

This single command creates everything you need for a full CRUD interface.

Scaffolds a complete Andurel project with the given name.

andurel new (alias: n) [project-name] [flags]

Generate models, controllers, and scaffolds from your existing database migrations.

andurel generate (alias: g) model NAME [flags]
andurel generate view (alias: v)
andurel generate controller (alias: c) NAME [action ...] [flags]
andurel generate scaffold (alias: s) NAME [flags]
andurel generate job (alias: j) NAME [flags]
andurel generate email (alias: e) NAME

generate model — Creates a model from a database migration, or updates an existing one. Fields, types, and timestamps are read from the migration automatically.

generate controller — Creates a controller, views, and routes for the given actions.

generate view — Generates Go code from .templ template files (runs templ generate).

generate scaffold — Convenience command that runs generate model + generate controller with full CRUD actions (index, show, new, create, edit, update, destroy).

Formats Go and Templ source files in the project.

andurel fmt (alias: f) [flags]

Runs go fmt ./..., golines -w -m 100 ., and templ fmt on views/ and email/ directories.

Manage the full database lifecycle.

andurel database (aliases: d, db)
andurel database create
andurel database drop [--force]
andurel database nuke [--force]
andurel database rebuild [--force] [--skip-seed]
andurel database seed
andurel database migrate (aliases: m, mig)

database migrate subcommands:

Starts the development server with live reload (powered by Shadowfax).

andurel run (alias: r)

Opens an interactive database console (usql) using connection details from .env.

andurel console (alias: c)

Manage CLI tools and binaries used by your project. Tools are defined in andurel.lock and downloaded to bin/.

andurel tool (alias: t)
andurel tool sync
andurel tool set-version <tool> <version>
andurel tool dblab (alias: d)
andurel tool mailpit (alias: m)

Add and list optional framework features.

andurel extension (aliases: ext, e)
andurel extension add (alias: a) [extension-name]
andurel extension list (alias: ls)

Available extensions: docker, aws-ses.

Outputs comprehensive framework documentation for AI assistants. Supports topic-specific subcommands:

andurel llm (alias: l)
andurel llm controllers (alias: c)
andurel llm models (alias: m)
andurel llm views (alias: v)
andurel llm router (alias: r)
andurel llm hypermedia (alias: h)
andurel llm jobs (alias: j)
andurel llm config (alias: cfg)

Upgrade framework-managed files and tool versions to the latest.

andurel upgrade (alias: up) [--dry-run]

Commit or create a branch before upgrading — this command modifies files in place.

Run comprehensive diagnostic checks (Go version, config, code quality, code generation).

andurel doctor (alias: doc) [--verbose]

myapp/
├── assets/              # Static assets
│   ├── css/            # Compiled CSS files
│   ├── js/            # JavaScript files
│   └── assets.go              
├── clients/             # External service clients
│   └── email/          # Email client (Mailpit/AWS SES)
├── cmd/
│   ├── app/            # Main web application
├── bin/
│   └── shadowfax       # Development server orchestrator
├── config/              # Application configuration
│   ├── app.go          # Sessions, tokens, security
│   ├── database.go     # Database connection
│   ├── email.go        # Email configuration
│   ├── telemetry.go    # Logging, tracing, metrics config
│   └── config.go       # Main config aggregator
├── controllers/         # HTTP request handlers
│   ├── controller.go   # Base controller utilities
│   ├── cache.go        # Cache control utilities
│   ├── pages.go        # Page controllers
│   └── assets.go       # Asset serving
├── css/                 # Source CSS files (Tailwind input)
├── database/
│   ├── migrations/     # SQL migration files
│   ├── queries/        # SQLC query definitions
│   └── sqlc.yaml       # SQLC user overlay config
├── email/               # Email functionality
│   ├── email.go        # Email client and sending logic
│   ├── base_layout.templ    # Base email template layout
│   └── components.templ     # Reusable email components
├── internal/            # Internal framework packages
│   ├── hypermedia/     # Datastar/SSE helpers
│   ├── renderer/       # Template rendering
│   ├── routing/        # Routing utilities
│   ├── server/         # Server configuration
│   └── storage/        # Storage utilities (+ SQLC base/effective config)
├── models/              # Data models and business logic
│   ├── model.go        # Base model setup
│   ├── factories/      # Model factories for testing
│   └── internal/db/    # Generated SQLC code (do not edit)
├── queue/               # Background job processing
│   ├── jobs/           # Job definitions
│   ├── workers/        # Worker implementations
├── router/              # Routes and middleware
│   ├── router.go       # Main router setup
│   ├── routes/         # Route definitions
│   ├── cookies/        # Cookie and session helpers
│   └── middleware/     # Custom middleware
├── services/            # Business logic services
│   ├── authentication.go    # Authentication service
│   ├── registration.go      # User registration service
│   └── reset_password.go    # Password reset service
├── telemetry/           # Observability setup
│   ├── logger.go       # Structured logging
│   ├── tracer.go       # Distributed tracing
│   ├── metrics.go      # Application metrics
│   └── helpers.go      # Telemetry utilities
├── views/               # Templ templates
│   ├── components/     # Reusable template components
│   ├── *.templ         # Template source files
│   └── *_templ.go      # Generated Go code (do not edit)
├── .env.example         # Example environment variables
├── .gitignore           # Git ignore patterns
├── andurel.lock         # Framework version lock file
├── Dockerfile           # Container build (docker ext)
├── go.mod               # Go module definition
└── go.sum               # Go module checksums

Contributions are welcome! Here's how to get started:

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Make your changes and add tests
4. Run quality checks: go vet ./... and golangci-lint run
5. Commit your changes: git commit -m 'Add amazing feature'
6. Push to the branch: git push origin feature/amazing-feature
7. Open a Pull Request

git clone https://github.com/mbvlabs/andurel
cd andurel
go mod download
go test ./...

This project is licensed under the MIT License - see the LICENSE file for details.

Andurel is built on top of excellent open-source projects:

• Echo - High-performance HTTP router and framework
• SQLC - Type-safe SQL code generation
• Templ - Type-safe Go templates
• Datastar - Hypermedia-driven frontend interactivity (RC6)
• River - Fast PostgreSQL-backed job queue and workflows
• OpenTelemetry - Observability framework for logs, traces, and metrics
• pgx - PostgreSQL driver and toolkit
• Tailwind CSS - Utility-first CSS framework
• Cobra - CLI framework

Inspired by Ruby on Rails and its philosophy that developer happiness and productivity matter. Built for developers who want to move fast without sacrificing type safety or code quality.

Here is a collection of sites and projects, I've built with this framework:

• MBV Blog | personal blog
• Master Golang | course platform
• Palantir | open sourced analytics platform (WIP)

If you build something cool with Andurel, let me know and I will add it to the list (or open a PR)!

Created by Morten Vistisen

Feel free to reach out to me on:

• Twitter/X
• Mail

If you have any questions!