Back to Leapkit
Resources

Leapkit

Everything you need to build Go web apps—routing, database, auth, and more. Production-ready out of the box.

Book a Free Scoping Call

LeapKit: Your Next Go App in a Leap

Open Source Go Web Framework by Wawandco

LeapKit is a carefully curated collection of Go packages that makes web development fast, simple, and production-ready. Built from 12+ years of shipping Go applications for 30+ SaaS companies.

Get Started with LeapKit →
View on GitHub →

What Is LeapKit?

LeapKit isn’t another bloated framework. It’s a thoughtfully composed set of tools and conventions that give you everything you need to build production Go web applications—without the complexity.

Philosophy

  • Batteries included — Authentication, database, migrations, and more work out of the box
  • Simplicity over complexity — Clean APIs that don’t require a PhD to understand
  • Production-ready — Battle-tested patterns from real SaaS applications
  • Go idiomatic — Follows Go conventions and best practices
  • HTMX-friendly — Built for modern hypermedia-driven applications

Why Choose LeapKit?

The Problem with Go Web Development

Go’s standard library is excellent, but building production web apps requires assembling dozens of packages:

  • Router (gorilla/mux, chi, echo?)
  • Database ORM (gorm, sqlx, raw SQL?)
  • Migrations (golang-migrate, goose?)
  • Authentication (roll your own?)
  • Sessions (which library?)
  • Validation (how many options?)
  • Testing setup (mock databases?)
  • Asset pipeline (webpack, esbuild?)

Hours of research. Days of setup. Weeks of integration.

The LeapKit Solution

LeapKit provides sensible defaults and working patterns so you can start building immediately:

# Install LeapKit CLI
go install github.com/wawandco/leapkit/cmd/leapkit@latest

# Create a new app
leapkit new myapp
cd myapp

# Run it
go run cmd/app/main.go

That’s it. You have a working web application with:

  • Database connection and migrations
  • User authentication and sessions
  • Asset pipeline configured
  • Hot reloading in development
  • Production deployment ready

What’s Included

Core Features

🚀 Application Structure

myapp/
├── cmd/
│   └── app/           # Application entry point
├── internal/
│   ├── app/           # Application initialization
│   └── migrations/    # Database migrations
├── public/            # Static assets
└── templates/         # HTML templates

Conventional structure that scales from MVP to enterprise.

🗄️ Database & Migrations

// Auto-migration on startup
kit.DB().AutoMigrate(
    &models.User{},
    &models.Post{},
)

// Or use raw SQL migrations
kit.DB().Exec(`
    CREATE INDEX idx_posts_user_id ON posts(user_id);
`)

PostgreSQL and SQLite support out of the box.

🔐 Authentication & Sessions

// Protect routes
kit.Use(auth.Middleware())

// Login handler
func LoginHandler(c *gin.Context) {
    user := auth.Authenticate(email, password)
    auth.Login(c, user)
}

Secure session management with multiple backend options.

🎨 HTMX Integration

<!-- templates/index.html -->
<button hx-post="/increment" hx-target="#counter">
    Click Me
</button>
<div id="counter">{{.Count}}</div>

Built-in HTMX support for modern, JavaScript-light applications.

🔥 Hot Reloading

Save a file, see changes instantly. No manual restart required during development.

📦 Asset Pipeline

CSS and JavaScript compilation, minification, and fingerprinting built-in. Works with Tailwind CSS out of the box.

Advanced Features

Background Jobs

// Define a job
kit.Jobs().Register("send_email", func(args ...any) error {
    email := args[0].(string)
    return emailService.Send(email)
})

// Enqueue it
kit.Jobs().Enqueue("send_email", "user@example.com")

WebSockets

kit.WebSocket("/ws", func(conn *websocket.Conn) {
    for {
        msg := conn.Read()
        conn.Write("Echo: " + msg)
    }
})

Middleware Stack

kit.Use(
    logging.Middleware(),
    recovery.Middleware(),
    csrf.Middleware(),
    auth.Middleware(),
)

Testing Utilities

func TestHomepage(t *testing.T) {
    app := kit.NewTestApp()
    resp := app.Get("/")
    
    assert.Equal(t, 200, resp.Code)
    assert.Contains(t, resp.Body, "Welcome")
}

Built-in test helpers with database transactions and fixtures.

Who Uses LeapKit?

LeapKit powers production applications at Wawandco and our clients:

  • Releaso — AI-powered release notes platform
  • Retabler — Intelligent data import automation
  • Personas — User persona creation tool
  • Multiple client SaaS applications

Battle-tested in production since 2023.

Getting Started

Installation

# Install LeapKit CLI
go install github.com/wawandco/leapkit/cmd/leapkit@latest

# Verify installation
leapkit version

Create Your First App

# Generate new application
leapkit new myapp

# Change to app directory
cd myapp

# Install dependencies
go mod tidy

# Run the app
go run cmd/app/main.go

# Visit http://localhost:3000

Development Workflow

# Development mode with hot reloading
go run cmd/app/main.go

# Run database migrations
go run cmd/db/main.go migrate

# Run tests
go test ./...

# Build for production
go build -o bin/app cmd/app/main.go

Documentation

Comprehensive documentation is available at leapkit.dev:

Community & Support

GitHub: github.com/wawandco/leapkit
Documentation: leapkit.dev
Issues & PRs: Welcome on GitHub
Discussions: GitHub Discussions

Built by Wawandco

LeapKit is developed and maintained by Wawandco, a software development company specializing in Go and HTMX. We’ve been shipping production Go applications for 12+ years and built LeapKit to share what we’ve learned.

Why we’re giving it away:

We believe in open source and the Go community. LeapKit makes our team more productive, and we want other developers to benefit too. Plus, it’s a great way to show our engineering philosophy in action.

Comparison with Other Go Frameworks

Feature LeapKit Gin Echo Buffalo
Batteries Included ✅ Yes ❌ Minimal ❌ Minimal ✅ Yes
Hot Reloading ✅ Built-in ❌ External ❌ External ✅ Built-in
Migrations ✅ Built-in ❌ External ❌ External ✅ Built-in
Auth ✅ Built-in ❌ External ❌ External ✅ Built-in
HTMX Support ✅ Native ⚠️ Manual ⚠️ Manual ⚠️ Manual
Complexity Low Low Low Medium
Maintenance ✅ Active ✅ Active ✅ Active ⚠️ Limited

Frequently Asked Questions

Is LeapKit production-ready?

Yes. LeapKit powers multiple production SaaS applications. We dogfood it extensively at Wawandco.

What’s the learning curve?

If you know Go, you can be productive with LeapKit in a day. The conventions are intuitive and well-documented.

Can I use LeapKit with my existing database?

Yes. LeapKit works with existing PostgreSQL and SQLite databases. Migrations are optional.

Does LeapKit support other databases?

Currently PostgreSQL and SQLite. MySQL support is on the roadmap.

Is LeapKit opinionated?

Yes, but not dogmatic. We provide sensible defaults that work for most applications, but you can customize or replace any component.

How does LeapKit compare to Buffalo?

Buffalo was an inspiration, but it’s no longer actively maintained. LeapKit is actively developed, lighter weight, and focused on modern patterns like HTMX.

Can I contribute to LeapKit?

Absolutely! We welcome contributions. See our Contributing Guide.

Is commercial support available?

Yes. Wawandco provides commercial support, training, and consulting for LeapKit. Contact us for details.

Start Building Today

go install github.com/wawandco/leapkit/cmd/leapkit@latest
leapkit new myapp
cd myapp && go run cmd/app/main.go

Your next Go app starts with a leap.

Get Started →