github.com/go-chi/chi

Chi feels like a natural extension of net/http rather than a framework fighting against it. The API is minimal and intuitive - you work with standard http.Handler and http.HandlerFunc everywhere, making it trivial to integrate existing middleware or migrate from stdlib routing. Route groups with sub-routers compose beautifully, and the context-based URL parameter extraction using chi.URLParam is straightforward.

Middleware ordering is explicit and predictable through the Use() chain, which eliminates the "magic" behavior found in heavier frameworks. The included middleware suite (logger, recoverer, timeout, etc.) provides sensible production-ready defaults without forcing you to use them. Error messages are clear when routes conflict or patterns are malformed.

The documentation is concise with practical examples showing common patterns like API versioning, protected routes, and mounting sub-applications. The lack of code generation or build-time tooling means zero setup friction - just import and start routing. Upgrading between minor versions has been painless in my experience, as the API surface is stable and breaking changes are rare.

Chi feels like an extension of net/http rather than a replacement, which makes onboarding incredibly smooth. If you know http.Handler and http.HandlerFunc, you already understand 90% of Chi. The routing syntax is clean and predictable - Route(), Get(), Post(), etc. work exactly as you'd expect. URL parameters with chi.URLParam() are straightforward, and the middleware stack is dead simple to reason about.

The documentation hits the sweet spot: concise README with clear examples covering common patterns like subrouters, middleware composition, and route grouping. When you make mistakes, error messages are typically from the standard library since Chi is such a thin layer. Debugging is easy because you can drop down to standard handlers at any point.

Community support is solid - most questions on Stack Overflow have answers, and GitHub issues show maintainer engagement. The _examples directory in the repo is particularly valuable, showing real patterns like JWT auth, CORS, timeout handling, and graceful shutdown. Common use cases like mounting APIs under prefixes or applying middleware to specific route groups just work without fighting the framework.

Chi feels like a natural extension of the standard library's http package. The API is immediately familiar if you've used net/http - it implements http.Handler and uses the same method signatures. I was productive within minutes of reading the README. The middleware system is particularly elegant, using simple function composition that's easy to reason about and debug.

Route parameters are straightforward with chi.URLParam(), and the router correctly handles trailing slashes and method-based routing without surprises. Error messages are clear when you mess up route patterns, and debugging is simple since there's no magic - just standard Go http handlers. The sub-router pattern with Route() makes organizing large APIs clean and testable.

Documentation is concise but complete, with practical examples that cover real-world scenarios like authentication middleware, rate limiting, and API versioning. The GitHub issues are actively maintained with helpful responses. Coming from other routers, the lack of struct tags or code generation is refreshing - it's just functions and handlers.