RapidGo

RapidGo

The Laravel of Go. A batteries-included web framework with 58 features, built on Gin + GORM + Cobra.

Why RapidGo?

Go has amazing HTTP routers (Gin, Echo, Fiber) — but no full application framework. Every Go project starts by assembling 15–20 packages for auth, ORM, sessions, queues, mail, validation, and more. RapidGo ships all of that out of the box.

RapidGo is NOT another HTTP router. It's built on top of Gin — the same way Laravel is built on Symfony, NestJS on Express, and Rails on Rack.

Feature Highlights

Core Application

• ✅ Dependency injection container — singleton and transient bindings with type-safe resolution
• ✅ Service providers — Register/Boot lifecycle pattern for modular bootstrapping
• ✅ Configuration — .env loading via godotenv with environment detection
• ✅ Structured logging — JSON logging via Go's log/slog
• ✅ Error handling — centralized middleware with JSON/HTML responses
• ✅ Plugin / module system — extensible plugin architecture with route, command, and event hooks

HTTP & Routing

• ✅ Gin-based router — route groups, resource routes, named routes, route model binding
• ✅ MVC controllers — ResourceController interface with 7 CRUD actions
• ✅ Middleware pipeline — registry with aliases and groups (auth, CORS, CSRF, rate limit, sessions, request ID)
• ✅ Input validation — built-in engine + struct-based via go-playground/validator
• ✅ API response helpers — standardized success/error/paginated envelope
• ✅ Views & templates — html/template with layouts, partials, and template functions
• ✅ WebSocket — upgrade, hub, broadcast, rooms/channels via coder/websocket
• ✅ API versioning — version-prefixed route groups
• ✅ GraphQL — handler with GraphiQL playground via graphql-go
• ✅ Static file serving — CSS, JS, images

Data & Database

• ✅ GORM ORM — PostgreSQL, MySQL, SQLite with models, relationships, hooks
• ✅ Migrations — schema management with up/down via CLI
• ✅ Seeders — interface-based registry with RunAll() and RunByName()
• ✅ Transactions — auto, manual, and nested transaction patterns
• ✅ Pagination — configurable page-based helper
• ✅ Soft deletes — DeletedAt field with WithTrashed and OnlyTrashed scopes
• ✅ Read/write splitting — separate read replica connections

Security & Authentication

• ✅ JWT authentication — stateless token auth via golang-jwt
• ✅ Session-based auth — stateful with 5 backends (database, Redis, file, memory, cookie)
• ✅ OAuth2 / social login — Google, GitHub, Facebook, and custom providers via x/oauth2
• ✅ TOTP two-factor auth — with bcrypt-hashed backup codes via pquerna/otp
• ✅ CSRF protection — double-submit cookie pattern with per-request tokens
• ✅ CORS — per-origin, per-method, per-header configuration
• ✅ Rate limiting — token bucket with per-IP, per-route, and per-user limits via ulule/limiter
• ✅ Crypto utilities — AES-256-GCM encryption, bcrypt hashing, HMAC-SHA256, secure random tokens
• ✅ Audit logging — who did what, when, with structured audit trail

Infrastructure

• ✅ Queue workers — background jobs with 4 drivers (database, Redis, memory, sync), per-job backoff
• ✅ Task scheduler — cron-based scheduling via robfig/cron
• ✅ Event system — publish-subscribe with sync/async dispatch
• ✅ Notification system — unified dispatch to database + email channels via Notifiable interface
• ✅ Caching — Redis, in-memory, and file-based with TTL support
• ✅ Mail — SMTP email via go-mail
• ✅ File storage — local filesystem and Amazon S3 via unified interface
• ✅ i18n — JSON-based translation files with locale detection
• ✅ Prometheus metrics — request duration, status codes, custom counters

CLI & Developer Experience

• ✅ Code generation — make:controller, make:model, make:service, make:provider, make:migration
• ✅ Database CLI — migrate, migrate:rollback, migrate:status, db:seed
• ✅ Server CLI — serve with --mode flag (web, api, ws, all)
• ✅ Worker CLI — work with --queues, --workers, --timeout
• ✅ Scheduler CLI — schedule:run
• ✅ Admin panel scaffolding — generates admin CRUD controllers and views

Deployment

• ✅ Graceful shutdown — signal handling with connection draining
• ✅ Health checks — liveness and readiness probe endpoints
• ✅ Docker — multi-stage Dockerfile + docker-compose
• ✅ Caddy integration — optional auto-HTTPS reverse proxy
• ✅ Multi-port serving — service mode for Web, API, WebSocket on separate ports
• ✅ WebSocket — real-time with rooms, broadcasting, heartbeat, and lifecycle callbacks
• ✅ Pagination — offset-based and cursor-based (infinite scroll) helpers

See all 58 features with package paths →

Quick Comparison

RapidGo vs HTTP routers — different categories entirely:

See the full comparison →

Architecture

Request → Middleware Pipeline → Router (Gin) → Controller → Service → Model → Database
               ↑                                                         ↓
          (auth, CSRF, CORS,                                      (PostgreSQL,
           rate-limit, session,                                    MySQL, SQLite)
           request-id, metrics)

Pattern: MVC + Services + Helpers

• Controllers — HTTP concerns only (parse request, call service, return response)
• Services — business logic and domain rules (no HTTP objects)
• Models — GORM data schemas, relationships, hooks
• Helpers — stateless utility functions across all layers

Principles: convention over configuration · explicit over magic · composition over inheritance · fail fast · single responsibility

Quick Start

# Install the CLI
go install github.com/RAiWorks/RapidGo/v2/cmd/rapidgo@latest

# Create a new project
rapidgo new myapp
cd myapp
cp .env.example .env

# Start the server
go run cmd/main.go serve

# Generate code
rapidgo make:controller UserController
rapidgo make:model User
rapidgo make:service UserService
rapidgo make:migration create_posts_table

# Database operations
rapidgo migrate
rapidgo db:seed

# Background workers
rapidgo work --queues=default,emails --workers=4
rapidgo schedule:run

Or clone the starter: RapidGo-starter

Technology Stack

Package Index

Hook System

The core/cli package provides 6 hooks for wiring application code to the framework:

cli.SetBootstrap(func(a *app.App, mode service.Mode) {
    a.Register(&providers.ConfigProvider{})
    a.Register(&providers.DatabaseProvider{})
    // ...
})

cli.SetRoutes(func(r *router.Router, c *container.Container, mode service.Mode) {
    routes.RegisterWeb(r)
    routes.RegisterAPI(r)
})

cli.SetJobRegistrar(jobs.RegisterJobs)
cli.SetScheduleRegistrar(schedule.RegisterSchedule)
cli.SetModelRegistry(models.All)
cli.SetSeeder(func(db *gorm.DB, name string) error {
    if name != "" {
        return seeders.RunByName(db, name)
    }
    return seeders.RunAll(db)
})

Documentation

License

MIT — Copyright (c) 2026 RAi Works