Explicit over implicit

Go Web Framework
Unified API. Driver-based.

21 packages. One API pattern. Zero configuration lock-in.

Full-stack or API-only. Your architecture, your choice.

Get Started View on GitHub

Three Pillars

What Sets Velocity Apart

Unified API

One pattern across all packages. Learn Velocity's API once—apply it to caching, queuing, mail, storage, logging, and more.

Driver-Based

Develop with SQLite, deploy with PostgreSQL. Test with in-memory cache, run with Redis. Infrastructure decisions belong in configuration, not code.

Flexible

Build what you need. Full-stack web app with Inertia + React, or API-only microservice. Same framework, same packages.

Driver-Based Architecture

Change Backends, Not Code

Every package with multiple backends uses the driver pattern.

Your code stays the same
cache.Put("user:1", data, time.Hour)
cache.Get("user:1")
.env changes per environment
# Development
CACHE_DRIVER=memory

# Production
CACHE_DRIVER=redis
PackageAvailable Drivers
cacheredis, file, memory
arcpostgres, sqlite
queuedatabase, redis, sqs
mailsmtp, mailgun, ses
storagelocal, s3
logfile, console

Unified Pattern

Fluent API, Every Package

One consistent interface across 21 packages.

Cache & Storage
cache.Get(key)
cache.Put(key, val, ttl)

storage.Get(path)
storage.Put(path, content)
Mail & Queue
mail.Send(message)
mail.To(addr).Send()

queue.Push(job)
queue.Later(job, delay)

Developer Experience

Why Velocity?

Go's power with modern developer experience.

Move Faster

  • Automatic Route Discovery

    Routes auto-register from your routes/ directory

  • RESTful Resources

    Built-in support for RESTful handler patterns

  • Smart Defaults

    Convention-based routing and auto-initialization

Ship with Confidence

  • Type Safety

    Full Go type checking throughout your application

  • Native Performance

    Go performance with minimal framework overhead

  • Production Ready

    Single binary deployment with embedded assets

How It Works

Not a DI Framework

Velocity is explicit. No containers, no service providers.

IoC containers → Direct imports
Hidden registration → Explicit init
Runtime resolution → Compile-time
Framework lifecycle → You own it

Direct imports

No magic. Import the package, call the function. Your IDE understands it, your compiler checks it.

import "github.com/velocitykode/velocity/pkg/cache"

cache.Get("user:1")

Explicit initialization

You decide when packages initialize. One line in your bootstrap, complete control over order and error handling.

func main() {
    cache.InitFromEnv()
    arc.InitFromEnv()
}

Compile-time safety

No runtime surprises. If it compiles, your dependencies are wired correctly. The compiler is your safety net.

// Typo? Compiler catches it.
cache.Gett("key") // ❌ Build error

// Wrong type? Compiler catches it.
cache.Put(123, val) // ❌ Build error

You own the lifecycle

No framework black box. You control initialization, shutdown, and everything in between. Debug with standard Go tools.

// Graceful shutdown? Your code.
defer cache.Close()
defer arc.Close()
21
Packages
1
API Pattern
0
Config Lock-in

Ready to Start?

Get Started in Seconds

go install github.com/velocitykode/vel@latest
Read the Docs