630k req/s. Zero allocations. Built-in SPA engine. This is Breeze.
Let me skip the humble intro. I built a Go HTTP framework that benchmarks 3× faster than Fiber on the same hardware, same payload. It's called Breeze, it's built on top of gnet's event loop, and it ships with features that most frameworks make you bolt on yourself.
Here's why I think it's worth your attention.
📊 The Numbers Don't Lie
Simple JSON endpoint. Same machine. Same payload.
| Framework | Requests/sec | vs Breeze |
|---|---|---|
| Breeze | ~630k | 1.0× |
| goFiber | ~210k | 0.33× |
| Echo | ~140k | 0.22× |
| Gin | ~120k | 0.19× |
| net/http | ~85k | 0.13× |
These are approximate numbers from my environment — run the benchmarks yourself for authoritative results.
🔍 How Is This Even Possible?
Breeze isn't another net/http wrapper. It's built on gnet, a non-blocking event-driven networking engine that makes direct epoll/kqueue syscalls. On top of that, I obsessed over every allocation in the hot path:
Stack-allocated router. Path segment matching uses a fixed [16]string array on the stack — no heap allocations. Parameter indexes are pre-computed at route registration, not at match time.
Zero-copy parsing. Raw bytes are converted to strings using unsafe.String — no copying. Header keys are lowercased in-place instead of creating new strings.
Smart worker pool. A fixed goroutine pool with a 16× buffered channel absorbs request bursts. When the queue is full, it spawns a goroutine instead of blocking the event loop. That's the critical difference — the event loop never stalls.
Response serialization without fmt.Sprintf. Status codes are mapped via array index. Buffers are pre-sized. Every nanosecond counts when you're serving 600k+ requests per second.
⚡ Show Me the Code
A complete working server in under 20 lines:
package main
import (
"runtime"
"github.com/nelthaarion/breeze"
middleware "github.com/nelthaarion/breeze/middlewares"
)
func main() {
router := breeze.NewRouter()
router.Use(middleware.RecoveryMiddleware())
router.Use(middleware.LoggingMiddleware())
router.Handle(breeze.GET, "/", func(ctx *breeze.Context) {
ctx.JSON(map[string]string{"status": "ok"})
})
router.Handle(breeze.GET, "/users/:id", func(ctx *breeze.Context) {
ctx.JSON(map[string]string{"id": ctx.Param("id")})
})
pool := breeze.NewWorkerPool(runtime.NumCPU())
app := breeze.New(router, pool)
app.Run(3000, true) // port, multiCore
}
That's it. One event loop per CPU core, RoundRobin load balancing, TCP_NODELAY enabled by default. No tuning required.
🔌 Native WebSocket — No Goroutine Per Connection
This is the one that makes people do a double-take.
Most Go frameworks spawn a goroutine for every WebSocket connection. Breeze doesn't — the WebSocket handler runs inside the gnet event loop. Zero extra goroutines. Zero per-connection memory overhead.
app := breeze.New(router, pool)
hub := app.WebSocket("/ws", &breeze.WSHandlerFunc{
Connect: func(conn *breeze.WSConn) {
conn.SendText("welcome")
},
Message: func(conn *breeze.WSConn, opcode byte, payload []byte) {
hub.BroadcastText(string(payload))
},
Close: func(conn *breeze.WSConn, code uint16, reason string) {
hub.BroadcastText("a user left")
},
})
The built-in WSHub handles broadcast, room management, and graceful disconnects. RFC 6455 compliant, auto-reconnect on the client side with exponential backoff.
🎨 The Template Engine That Thinks It's an SPA
This is the feature I'm most excited about. Breeze ships a full server-side template engine that automatically turns your multi-page app into a single-page app. No React. No Vue. No build step.
Here's how it works:
1. You write normal server-rendered views with layouts and components:
<!-- views/layout.html -->
{{define "layout"}}
<!DOCTYPE html>
<html>
<body>
{{component "nav" .}}
<div id="breeze-app">
{{template "content" .}}
</div>
</body>
</html>
{{end}}
<!-- views/home.html -->
{{define "content"}}
<h1>Hello, {{.Data.Name}}!</h1>
{{component "card" (map "title" "Welcome" "body" "Try clicking a link")}}
{{end}}
2. You register routes the simple way:
engine := breeze.NewTemplateEngine(breeze.TemplateConfig{
ViewsDir: "views",
ComponentsDir: "components",
LayoutFile: "views/layout.html",
})
router.View("/", engine, "home", func(ctx *breeze.Context) any {
return map[string]any{"Name": "World"}
})
3. The magic happens automatically. On every full-page render, Breeze injects a JavaScript runtime before </body>. When a user clicks an internal link, the runtime intercepts it, fetches only the content block (via X-Breeze-Partial: true header), and swaps #breeze-app innerHTML. No full page reload. pushState handles the URL. popstate handles back/forward.
Your multi-page app just became a SPA. You didn't write a single line of JavaScript.
But wait — there's more. The template engine also gives you:
Reactive data store — page data is embedded as JSON, accessible viabreeze.data(), watchable viabreeze.watch()
Client-side re-rendering —breeze.render('card', newData, '#target')re-renders a component without hitting the server (it uses an embedded Go-template subset interpreter)
Fragment routes —router.Fragment('/fragments/stats', engine, "stats", dataFn)serves bare HTML fragments for polling or partial updates
SPA form handling — POST forms are intercepted and submitted viafetch(), response HTML is swapped in. Progressive enhancement means forms still work without JS
Polling built in —breeze.poll('/fragments/stats', '#stats-box', 2000)auto-refreshes a fragment every 2 seconds
Dev mode hot reload — setDevMode: trueand template changes are reflected instantly without restarting
🛡️ 9 Middleware, Zero External Dependencies
Everything you need for production, shipped with the framework:
// JWT with access + refresh tokens, role-based auth, custom claims validator
router.Use(middleware.JWTAuthMiddleware(middleware.JWTOptions{
AccessSecret: "secret",
RefreshSecret: "refresh-secret",
RequiredRoles: []string{"admin"},
}))
// CORS with automatic OPTIONS preflight
router.Use(middleware.CORSMiddleware(middleware.CORSOptions{
AllowOrigins: "https://myapp.com",
AllowMethods: "GET,POST,PUT,DELETE,OPTIONS",
}))
// Per-route rate limiting
router.Handle(breeze.POST, "/login", loginHandler,
middleware.NewRateLimiter(middleware.RateLimiterOptions{
Requests: 5,
Per: time.Minute,
}),
)
// Auto Brotli → Gzip → Deflate compression
router.Use(middleware.CompressionMiddleware())
// Security headers (CSP, HSTS, X-Frame-Options, etc.)
router.Use(middleware.DefaultSecurityMiddleware())
// Swagger docs from Go struct annotations
router.Use(middleware.SwaggerMiddleware(router, middleware.SwaggerOptions{
Title: "My API", Version: "1.0.0",
}))
Also included: Logger, Panic Recovery, and ETag Cache.
🆚 How It Compares
| Breeze | Fiber | Gin | Echo | |
|---|---|---|---|---|
| Engine | gnet event loop | fasthttp | net/http | net/http |
| Hot path allocs | ~0 | Low | Moderate | Moderate |
| WebSocket | Native, zero-goroutine | fasthttp-based | gorilla/websocket | gorilla/websocket |
| Template + SPA | Built-in | Separate | Separate | Separate |
| Swagger/OpenAPI | Built-in | Third-party | Third-party | Third-party |
| Middleware | 9 built-in | Growing | Largest ecosystem | Good built-in set |
| net/http compat | No | No | Yes | Yes |
Honest take: If you need deep net/http ecosystem compatibility, Gin or Echo are still the safe choices. But if you're starting fresh and want maximum performance with modern features baked in — Breeze is worth a serious look.
📦 Install and Run
go get github.com/nelthaarion/breeze
Requires Go 1.24.3+. Pulls in gnet v2, go-json, brotli, and golang-jwt/jwt.
🔮 What's Next
Real-time Dashboard — live route explorer, request monitor, ORM query monitor (already in progress)
gRPC support — leveraging gnet for high-performance gRPC
More middleware — OAuth2, OpenTelemetry
Template engine enhancements — hot-reload improvements, more built-in functions
Links:
- 📖 Docs: nelthaarion.github.io/breeze
- ⭐ GitHub: github.com/nelthaarion/breeze
I built Breeze because I was tired of choosing between speed and features. If that resonates with you, try it out and let me know what you think. I'm active on GitHub issues and open to contributions.
What's your current Go framework of choice, and what would make you switch? Let's talk in the comments. 👇
Tags: #go #golang #webframework #performance #breeze #open_source
SOCIAL SHARE CARD GENERATOR