Getting Started with Chi: A Lightweight Router for Go

Chi has emerged as one of the most popular and lightweight HTTP routers for Go developers, offering a perfect balance between simplicity and functionality. Today, let’s dive into why Chi might be your next go-to router for web applications.

What Makes Chi Special?

Chi stands out in the Go ecosystem for several compelling reasons. It’s built on top of the standard net/http library, which means you’re working with familiar interfaces while getting additional powerful features. The router is designed to be minimal yet fully featured, making it an excellent choice for both small projects and large-scale applications.

Getting Started with Chi

First, let’s install Chi in your Go project:

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

Here’s a simple example to get you started:

package main

import (
    "net/http"
    "github.com/go-chi/chi/v5"
)

func main() {
    r := chi.NewRouter()

    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Welcome to Chi!"))
    })

    http.ListenAndServe(":3000", r)
}

Key Features and Best Practices

Middleware Support

One of Chi’s strongest features is its middleware system. You can easily add middleware for logging, authentication, or any custom functionality:

r.Use(middleware.Logger)
r.Use(middleware.RequestID)
r.Use(middleware.Recoverer)

URL Pattern Routing

Chi provides intuitive URL pattern matching with parameters:

r.Get("/users/{userID}", func(w http.ResponseWriter, r *http.Request) {
    userID := chi.URLParam(r, "userID")
    // Handle the request
})

Grouping Routes

You can organize your routes into logical groups:

r.Route("/api", func(r chi.Router) {
    r.Route("/posts", func(r chi.Router) {
        r.Get("/", getAllPosts)
        r.Post("/", createPost)
        r.Get("/{postID}", getPost)
    })
})

Real-World Applications

Chi shines in real-world scenarios where you need to build maintainable APIs. Here’s a practical example of structuring an API endpoint with proper error handling:

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

    user, err := database.GetUser(userID)
    if err != nil {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }

    json.NewEncoder(w).Encode(user)
}

Performance Considerations

Chi is designed to be lightweight and fast. It achieves this through:

• Zero dynamic allocations in the hot paths
• No middleware overhead if you don’t use it
• Clean interfaces that allow for easy testing and mocking

Conclusion

Chi provides an excellent balance of features, performance, and simplicity. Whether you’re building a small API or a large-scale web application, Chi’s intuitive design and powerful features make it a solid choice for Go developers.