Forem: Jack Prescott

Building a minimal Go framework in public (v0.1.3)

Jack Prescott — Tue, 20 Jan 2026 05:58:59 +0000

What happens when you build a web framework with one simple rule: zero dependencies? That's the question behind Marten, a minimal HTTP framework built entirely on Go's standard library.

The Philosophy

Most Go web frameworks pull in dozens of dependencies. Gin has 9 direct dependencies. Echo has 11. Fiber has 15. Each dependency brings its own dependencies, and suddenly your go.mod looks like a phone book.

Marten takes a different approach: use only what Go gives you. No external packages. No vendor lock-in. Just net/http, encoding/json, and the rest of the standard library.

What It Looks Like

Here's a complete API in Marten:

package main

import (
    "github.com/gomarten/marten"
    "github.com/gomarten/marten/middleware"
)

func main() {
    app := marten.New()

    app.Use(middleware.Logger)
    app.Use(middleware.Recover)

    app.GET("/", func(c *marten.Ctx) error {
        return c.OK(marten.M{"message": "Hello, World!"})
    })

    app.GET("/users/:id", func(c *marten.Ctx) error {
        id := c.ParamInt("id")
        return c.OK(marten.M{"id": id})
    })

    app.Run(":8080")
}

Clean. Familiar. No magic.

The Core Features

Fast Routing with Radix Trees

Marten uses a radix tree router for efficient path matching. It handles path parameters (:id), wildcards (*filepath), and route groups:

api := app.Group("/api/v1")
api.GET("/users", listUsers)
api.GET("/users/:id", getUser)
api.POST("/users", createUser)

Middleware That Makes Sense

Middleware in Marten is just a function that wraps a handler:

func Timer(next marten.Handler) marten.Handler {
    return func(c *marten.Ctx) error {
        start := time.Now()
        err := next(c)
        log.Printf("took %v", time.Since(start))
        return err
    }
}

The framework includes 14 built-in middleware: Logger, Recover, CORS, RateLimit, BasicAuth, Timeout, Secure, BodyLimit, Compress, ETag, RequestID, Static, and NoCache.

Context Pooling

Every request gets a Ctx object from a sync.Pool. This reduces allocations and keeps memory usage low, even under heavy load:

func handler(c *marten.Ctx) error {
    // Path parameters
    id := c.Param("id")

    // Query parameters
    page := c.QueryInt("page")

    // JSON binding
    var user User
    c.Bind(&user)

    // Response helpers
    return c.OK(user)
}

Static File Serving

The latest release (v0.1.3) adds static file serving with all the features you'd expect:

app.Use(middleware.StaticWithConfig(middleware.StaticConfig{
    Root:   "./public",
    Prefix: "/static",
    MaxAge: 3600,
    Browse: false,
}))

Content-type detection, HTTP caching (If-Modified-Since), directory browsing, and security against directory traversal attacks—all built-in.

The Performance Story

How does a zero-dependency framework perform? Surprisingly well.

Benchmarks against Gin, Echo, and Chi show Marten holding its own:

Benchmark	Marten	Gin	Echo	Chi
Static Route	1464 ns/op	1336 ns/op	1436 ns/op	2202 ns/op
Param Route	1564 ns/op	1418 ns/op	1472 ns/op	2559 ns/op
JSON Response	1755 ns/op	2050 ns/op	1835 ns/op	1868 ns/op

Not the fastest, but competitive. And with zero dependencies.

Real-World Use Cases

Microservices

When you're building dozens of microservices, dependency bloat adds up. Marten keeps your Docker images small and your build times fast.

REST APIs

Build production-ready APIs with built-in middleware for logging, rate limiting, CORS, and authentication:

app := marten.New()

app.Use(
    middleware.RequestID,
    middleware.Logger,
    middleware.Recover,
    middleware.CORS(middleware.DefaultCORSConfig()),
    middleware.RateLimit(middleware.RateLimitConfig{
        Max:    100,
        Window: time.Minute,
    }),
)

api := app.Group("/api/v1")
api.GET("/users", listUsers)
api.POST("/users", createUser, authMiddleware)

Single Page Applications

Serve your SPA with automatic fallback to index.html for client-side routing:

// API routes
app.GET("/api/users", listUsers)

// Serve static files
app.Use(middleware.Static("./dist"))

// SPA fallback
app.NotFound(func(c *marten.Ctx) error {
    if strings.HasPrefix(c.Path(), "/api/") {
        return c.NotFound("endpoint not found")
    }
    // Serve index.html for client-side routing
    return c.HTML(200, indexHTML)
})

Learning and Teaching

Want to understand how web frameworks work? Read Marten's source. It's ~2,000 lines of readable Go code. No abstractions hiding abstractions.

The Testing Story

Marten v0.1.3 ships with 325 tests covering:

Unit tests for every component
Integration tests for real-world workflows
Stress tests with 1,000+ concurrent requests
Edge cases and error conditions

All tests pass with Go's race detector. No known memory leaks. Production-ready.

What's Missing (And Why)

Marten doesn't have:

ORM integration: Use database/sql directly
Template engine: Use html/template from stdlib
Validation library: Write your own or use a third-party package
WebSocket support: Coming in a future release

The philosophy is simple: if the standard library can do it, use the standard library. If you need more, add it yourself.

The Roadmap

Future releases will add:

WebSocket middleware
Template rendering helpers
Session management middleware
Enhanced static file serving options

But always with the same constraint: zero dependencies.

Try It Yourself

go get github.com/gomarten/marten@v0.1.3

Check out the examples for CRUD APIs, JWT auth, file servers, and more.

The Takeaway

Marten isn't trying to replace Gin or Echo. It's an experiment in minimalism. A proof that you can build a capable web framework without pulling in the world.

Sometimes, less is more.

Links:

GitHub: https://github.com/gomarten/marten
Documentation: https://gomarten.github.io/docs
Discussions: https://github.com/gomarten/marten/discussions

Why Go's Ecosystem is Your Secret Weapon in 2026

Jack Prescott — Fri, 16 Jan 2026 18:25:22 +0000

While everyone's chasing the shiniest new framework, Go developers are shipping production code at breakneck speed. Here's what makes Go's ecosystem different—and why it might be exactly what your next project needs.

The Standard Library is Your Best Friend

Go's standard library is ridiculously complete. Need an HTTP server? It's built-in. JSON parsing? Standard library. WebSockets? Yep. Cryptography? Already there.

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, Production!")
    })
    http.ListenAndServe(":8080", nil)
}

That's a production-ready HTTP server in 6 lines. No npm install, no dependency hell, no vulnerabilities in your 847 transitive dependencies.

Tools That Actually Work Together

Go's tooling isn't fragmented across competing projects. Everything just works:

go fmt - Code formatting (zero configuration)
go test - Testing framework (built-in)
go mod - Dependency management (no more version conflicts)
go build - Compilation to a single binary (deploy anywhere)
go vet - Static analysis (catch bugs before runtime)

No setup. No config files. No "which tool should we use?" debates. Just run the command and get work done.

Single Binary Deployment Changes Everything

Build your app. Get one executable. Deploy it anywhere. No runtime to install, no containers required (though they work great too), no "it works on my machine" moments.

GOOS=linux GOARCH=amd64 go build -o myapp

That's it. You just cross-compiled for Linux from your Mac. Ship it to production.

The Libraries You Actually Need

Go's ecosystem prioritizes quality over quantity. The most popular libraries are maintained, well-documented, and stable:

Web Frameworks:

gin - Fast, minimalist HTTP framework
echo - High performance, extensible
fiber - Express-inspired, lightning fast
marten - Simple Elegant, nothing in the way philosophy

Databases:

pgx - PostgreSQL driver (superior performance)
sqlx - SQL extensions with minimal overhead
gorm - Full ORM when you need it

Infrastructure:

cobra - CLI applications (powers kubectl, GitHub CLI)
viper - Configuration management
zap/zerolog - Structured logging that's actually fast

Performance That Scales With You

Go isn't just fast on benchmarks—it's fast in production. That side project you built? It'll handle your first million users without a rewrite.

Goroutines make concurrency natural, not nightmarish
Memory usage is predictable and low
Garbage collection pauses are measured in microseconds
CPU efficiency means lower cloud bills

The Community Gets It

Go developers share a culture of pragmatism. Libraries are focused, APIs are clean, and there's a shared understanding that simple is better than clever.

Browse GitHub's trending Go repos. You'll find:

Tools that solve real problems
Documentation that explains why, not just how
Code you can read and understand
Projects that are maintained, not abandoned

Real Companies, Real Scale

Go isn't a hobbyist language. It powers infrastructure at:

Docker - Containerization platform
Kubernetes - Container orchestration
Terraform - Infrastructure as code
Cloudflare - Global CDN and security
Uber - Microservices backbone
Twitch - Real-time streaming infrastructure
Dropbox - File synchronization

These companies chose Go when they needed reliability at scale. That's not an accident.

Your Productivity Multiplier

Here's what actually happens when you use Go:

Week 1: "This feels weird. Where are all the features?"

Week 4: "I'm shipping code faster than I expected."

Week 12: "I haven't touched this service in two months and it's still running perfectly."

Week 24: "Why did I ever think I needed a complex framework?"

Start Today

You don't need permission. You don't need a complete rewrite. Start small:

Build a CLI tool - Replace that bash script
Create a microservice - Handle one task exceptionally well
Write an API - See how fast you can ship

// Your first Go program
package main

import "fmt"

func main() {
    fmt.Println("Hello, Go ecosystem!")
}

Run go run main.go. That's it. You're a Go developer now.

The Bottom Line

Go's ecosystem isn't trying to be everything to everyone. It's optimized for one thing: helping you build reliable software that ships fast and runs forever.

No drama. No hype cycles. No framework fatigue. Just tools that work, libraries that last, and code that scales.

The best time to learn Go was five years ago. The second best time is right now.

What's your Go ecosystem experience? Drop a comment below—I'd love to hear what you're building!

P.S. If you found this helpful, follow me for more practical takes on modern development. Let's build something great.

Marten vs Chi: Not All Go Web Frameworks Are Created Equal

Jack Prescott — Sun, 11 Jan 2026 15:20:01 +0000

When I tell people about Marten, I often hear: "Isn't that just like Chi?"

Short answer: No.

Long answer: Let me show you why these frameworks, despite both being minimal Go web routers, are actually solving different problems.

The 30-Second Pitch

Both Marten and Chi are:

✅ Zero-dependency (pure stdlib)
✅ Fast radix tree routing
✅ Middleware support
✅ Lightweight and performant

But that's where the similarities end. Let's dig into what actually matters.

The Handler Signature: Where Everything Diverges

This is the fundamental difference that changes everything:

Chi: Pure Stdlib

func handler(w http.ResponseWriter, r *http.Request) {
    user := User{Name: "Alice"}
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(200)
    json.NewEncoder(w).Encode(user)
}

Marten: Framework Abstraction

func handler(c *marten.Ctx) error {
    user := User{Name: "Alice"}
    return c.OK(user)
}

This isn't just syntax sugar - it's a completely different programming model. Let me show you why.

Error Handling: Manual vs Automatic

Chi: You Handle Everything

func getUser(w http.ResponseWriter, r *http.Request) {
    id := chi.URLParam(r, "id")

    user, err := db.GetUser(id)
    if err != nil {
        w.WriteHeader(500)
        json.NewEncoder(w).Encode(map[string]string{
            "error": err.Error(),
        })
        return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(200)
    json.NewEncoder(w).Encode(user)
}

Marten: Framework Handles Errors

func getUser(c *marten.Ctx) error {
    id := c.Param("id")

    user, err := db.GetUser(id)
    if err != nil {
        return err // Framework catches this
    }

    return c.OK(user)
}

// In main.go
app.OnError(func(c *marten.Ctx, err error) {
    log.Printf("Error: %v", err)
    c.JSON(500, marten.E(err.Error()))
})

The difference: Chi gives you control. Marten gives you consistency.

Safety: Guard Rails vs. Freedom

Route Conflict Detection

Marten panics at startup on conflicting routes:

app.GET("/users/:id", handler1)
app.GET("/users/:userId", handler2) // PANIC: route conflict!

Chi silently allows this (last route wins):

r.Get("/users/{id}", handler1)
r.Get("/users/{userId}", handler2) // No error, handler2 wins

Double-Write Prevention

Marten tracks response state:

func handler(c *marten.Ctx) error {
    c.Status(200)
    c.Status(404) // Ignored - already written
    return nil
}

Chi lets you shoot yourself in the foot:

func handler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(200)
    w.WriteHeader(404) // Runtime error!
}

Performance: Different Approaches

Marten: Context Pooling

// Internal implementation
app.pool = sync.Pool{
    New: func() any {
        return &Ctx{
            params: make(map[string]string),
            store:  make(map[string]any),
        }
    },
}

Marten reuses context objects with sync.Pool, reducing allocations per request.

Chi: No Pooling

Chi allocates fresh contexts every request. It's still fast, but has different memory characteristics.

Benchmark difference: Marten typically shows 10-15% fewer allocations in high-throughput scenarios.

The Type Incompatibility Problem

Here's something crucial: You cannot mix Chi and Marten middleware.

// Chi middleware
func chiLogger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // ...
    })
}

// Marten middleware
func martenLogger(next marten.Handler) marten.Handler {
    return func(c *marten.Ctx) error {
        // ...
    }
}

These are fundamentally incompatible types. You'd need adapters to convert between them.

The Motorcycle vs Sports Car Analogy

Chi = Motorcycle 🏍️

Raw, direct control
You feel every operation
Manual everything
Experienced riders love it
"Don't help me, I know what I'm doing"

Marten = Sports Car 🏎️

Fast with modern conveniences
Safety features built-in
Automatic transmission with manual mode
Assists when needed, stays out of your way otherwise
"Help me go fast safely"

Real-World Code Comparison

Let's build a simple CRUD endpoint:

Chi Version

func createUser(w http.ResponseWriter, r *http.Request) {
    var user User

    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        w.WriteHeader(400)
        json.NewEncoder(w).Encode(map[string]string{"error": "invalid JSON"})
        return
    }

    if err := validate(user); err != nil {
        w.WriteHeader(400)
        json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
        return
    }

    if err := db.Create(&user); err != nil {
        w.WriteHeader(500)
        json.NewEncoder(w).Encode(map[string]string{"error": "database error"})
        return
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(201)
    json.NewEncoder(w).Encode(user)
}

Marten Version

func createUser(c *marten.Ctx) error {
    var user User

    if err := c.Bind(&user); err != nil {
        return c.BadRequest("invalid JSON")
    }

    if err := validate(user); err != nil {
        return c.BadRequest(err.Error())
    }

    if err := db.Create(&user); err != nil {
        return err // Caught by OnError handler
    }

    return c.Created(user)
}

40% less code. Same functionality. More readable.

When to Choose Which?

Choose Chi If:

✅ You want maximum stdlib compatibility
✅ You're migrating from http.ServeMux
✅ You prefer explicit control over everything
✅ You want to build your own abstractions
✅ You need the mature Chi ecosystem

Choose Marten If:

✅ You want Echo/Fiber ergonomics in pure Go
✅ You prefer safety features (conflict detection, write protection)
✅ You want less boilerplate
✅ You're building REST APIs quickly
✅ You value consistent error handling

The Ecosystem Question

Chi's advantage: 13+ years of community packages, battle-tested in production.

Marten's advantage: 13 built-in middleware that cover 90% of use cases:

Logger, Recover, CORS, RateLimit
BasicAuth, Compress, ETag, NoCache
Timeout, BodyLimit, Secure, RequestID

You trade ecosystem breadth for batteries-included convenience.

Migration Path

Chi → Marten

Requires rewriting handlers (signature change), but middleware concepts translate directly:

// Chi
r.Use(chiMiddleware)
r.Get("/users", getUsers)

// Marten equivalent
app.Use(martenMiddleware)
app.GET("/users", getUsers)

Marten → Chi

Similar effort - handler signatures must change, but routing logic stays the same.

Neither migration is trivial due to the type incompatibility.

My Take

After building with both:

Chi is the right choice when you want to stay close to the stdlib and have full control. It's a routing library that doesn't impose opinions.

Marten is the right choice when you want to ship features quickly with modern conveniences. It's an opinionated framework that reduces boilerplate.

They're not competitors - they're solving different problems:

Chi: "I want routing and nothing else"
Marten: "I want a complete foundation for REST APIs"

Try It Yourself

Chi

go get -u github.com/go-chi/chi/v5

r := chi.NewRouter()
r.Use(middleware.Logger)
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello Chi"))
})
http.ListenAndServe(":3000", r)

Marten

go get github.com/gomarten/marten

app := marten.New()
app.Use(middleware.Logger)
app.GET("/", func(c *marten.Ctx) error {
    return c.Text(200, "Hello Gomarten")
})
app.Run(":3000")

Conclusion

Chi and Marten are NOT the same.

They share superficial similarities but have fundamentally different:

Handler signatures (incompatible types)
Programming models (manual vs automatic)
Safety guarantees (permissive vs protective)
Performance characteristics (no pooling vs pooling)

Pick the one that matches your philosophy:

🏍️ Chi for control and stdlib purity
🏎️ Marten for speed and convenience

Both are excellent tools. Neither is "better" - they're just different.

What's your take? Are you Team Chi or Team Marten? Let me know in the comments! 👇

Marten is open source and actively maintained. Check it out at github.com/gomarten/marten

Introducing Marten the new Go web framework

Jack Prescott — Sat, 10 Jan 2026 07:52:08 +0000

Introducing Marten – The Go Web Framework Where Nothing Gets In Your Way

Jack Prescott ・ Jan 9

#webdev #go #backend

Introducing Marten – The Go Web Framework Where Nothing Gets In Your Way

Jack Prescott — Fri, 09 Jan 2026 13:12:35 +0000

Hey Go community 👋

If you’ve ever felt that:

Gin is great but the custom context wrapping makes things leak into your business logic
Chi is beautifully minimal but you end up pulling in 5–10 extra middleware packages anyway
You just want something clean, fast, and zero external dependencies

…then I built Marten exactly for that feeling.

What is Marten?

Marten is a minimalist Go web framework with one core philosophy:

"The framework you reach for when you want nothing in the way."

It gives you:

Ergonomic handler helpers (c.JSON, c.Bind, c.Param, c.Query, etc.)
Full stdlib compatibility – real context.Context is untouched at c.Request.Context()
Zero external dependencies – just net/http + Go stdlib
Built-in production middleware suite (no extra imports needed):
- gzip compression (with pooling)
- CORS (configurable, secure wildcard handling)
- Secure headers (HSTS, XSS-Protection, CSP, etc.)
- Rate limiting
- Timeout
- Body limit
- Basic auth
- Request ID
- No-cache
- ETag
- Panic recovery
- Logger

All applied via clean global/group/route-level chaining.

Quick Hello World

package main

import "github.com/gomarten/marten"

func main() {
    app := marten.New()

    app.GET("/", func(c *marten.Ctx) error {
        return c.JSON(200, map[string]string{"message": "Hello from Marten! 🚀"})
    })

    // Add middleware in one line
    app.Use(marten.Middleware.Recover, marten.Middleware.Logger, marten.Middleware.Compress())

    app.Run(":8080")
}

Why Another Framework?

Because sometimes you want:

Gin-like productivity without the custom context baggage
Chi-like purity with more batteries included
The confidence that your app will compile and behave the same 5 years from now (no dependency hell)

Try It Out

go get github.com/gomarten/marten

Repo: https://github.com/gomarten/marten

Docs & examples are still growing, but the code is small (~2k LOC) and very easy to read.

Would love to hear your thoughts:

Do you prefer zero deps even if it means slightly more explicit code?
What's your current favorite Go web stack in 2026?

Happy coding! 🐾