Zinc

v0.3.0MITGo 1.25+

Galvanize `net/http`.

The high-performance, minimalist web layer for Go. Routing, binding, errors, and 29 middleware, applied as a thin coat over the standard library you already trust.

Get started GitHub

RouterEdit the path, or pick an example

GET200

/usersstatic
/42{id}
/postsstatic
/7{post}

/
healthhealth
users
mecurrentUser
{id} = "42"showUser
posts
{post} = "7"showPost
files
{path...}serveFile

app.Get("/users/{id}/posts/{post}", showPost)c.Param("id")   // "42"c.Param("post") // "7"// Literals compare without case; captured values keep theirs.

app.Get("/users/me", currentUser)// Also matches /users/{id}, but static segments outrank parameters.

app.Get("/users/{id}", showUser)c.Param("id") // "42"// Literals compare without case; captured values keep theirs.

app.Get("/files/{path...}", serveFile)c.Param("path") // "css/app.css"// The catch-all captures the rest of the path.

// No route matches GET /teams/9.// The app's not-found handler answers 404.

app.Get("/users/{id}/posts/{post}", showPost)c.Param("id")   // "42"c.Param("post") // "7"// Literals compare without case; captured values keep theirs.

What you get

Everything a service needs. Nothing it doesn't.

Follow one request through Zinc, from the first middleware to the response.

app.Use(
    middleware.RequestID(),
    middleware.RequestLogger(),
    middleware.Recover(),
    middleware.Secure(),
)

api := app.Group("/api", middleware.ContextTimeout(5*time.Second))

L2Every response carries an ID that your logs share.Guide →

GET /api/users/42

200 OK

X-Request-Id: 9f2c4e1a7b3d5c8e0a6f1b2c3d4e5f60

X-Content-Type-Options: nosniff

X-Frame-Options: SAMEORIGIN

api := app.Group("/api", requireAuth)

api.Get("/users/{id}", func(c *zinc.Context) error {
    return c.JSON(zinc.Map{"id": c.Param("id")})
})

app.RouteNotFound("/api/{tail...}", apiNotFound)

L4{id} is captured from the path and read with c.Param.Guide →

GET /api/users/42

200 OK

{"id":"42"}

type CreateUser struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

app.Post("/users", func(c *zinc.Context) error {
    var in CreateUser
    if err := c.Bind().JSON(&in); err != nil {
        return zinc.ErrBadRequest.WithCause(err)
    }
    return c.Status(zinc.StatusCreated).JSON(in)
})

L8Decodes the body into CreateUser; bad input becomes a 400.Guide →

POST /users {"name":"Ada","email":"ada@example.com"}

201 Created

{"name":"Ada","email":"ada@example.com"}

app.Get("/users/{id}", func(c *zinc.Context) error {
    user, err := users.Find(c.Param("id"))
    if err != nil {
        return zinc.ErrNotFound.WithMessage("user not found")
    }
    return c.JSON(user)
})

L4Return an error; the error handler writes the response.Guide →

GET /users/nope

404 Not Found

user not found

How it fits

A thin coat, not a new engine.

Galvanizing protects steel without replacing it. Zinc does the same for net/http: your app is still an http.Handler, and standard handlers, middleware, and servers plug straight in.

Pick one to see where it plugs into the stack.

Run it on a server you configure
```
server.Handler = app
```

Serve a route with any standard handler

app.HandleHTTP("GET /metrics", promhttp.Handler())

Wrap the app in standard middleware

app.UseHTTP(otelhttp.NewMiddleware("api"))

Zinc and net/http →

Section A–Arequest ↑ · response ↓

Your applicationhandlers · services · packages

listUserscreateUserpromhttp.Handler()

zinc.HandlerFunchttp.Handler

Zincrouting · binding · errors · middleware

Standard middlewareotelhttp · func(http.Handler) http.Handler

net/httpthe standard library, untouched

http.Server{Handler: app}*http.Requesthttp.ResponseWriter

http.Handler inhttp.Handler out

Measured, in the repo

60/ 77

Scenarios where Zinc recorded the lowest latency against Gin, Echo, and Chi. Gin led 12, Chi 3, and Echo 2. Zinc was measured on 25 September; rival samples are from 24 September.

Zinc fastestA rival fastest

Mixed-date comparison25 September 2026Apple M1 Pro · go1.27.1 · commit 42e11d2

Full benchmark report →

HelloWorldns/op · lower is faster

Zinc86.75fastest
Gin136.91.58×
Echo152.91.76×
Chi180.82.08×

Middleware

A periodic table of production parts.

Numbered in chain order: each part wraps everything after it. Select parts to galvanize them into a stack, and the table writes the app.Use call in the right order.

Start from

Observe1–6Sees every request, so it wraps the rest

Contain7–11Bounds panics, time, size, and load

Shape12–15Normalises the URL before routing

Guard16–24Decides who gets in

Carry25–29Encodes and serves the response

Your compound

RiLgRcSh

4 parts, outermost first

main.go

app.Use(
	middleware.RequestID(),
	middleware.RequestLogger(),
	middleware.Recover(),
	middleware.Secure(),
)

Coat your first service.

Start a new API in a few minutes, or add Zinc to a service you already run.