When building web applications or APIs in Go, choosing the right HTTP router can significantly impact performance, especially at scale. This article analyzes and compares the performance characteristics of popular Go HTTP routers to help you make an informed choice for your next project.

Introduction

The HTTP router is a critical component in any web application, responsible for matching incoming requests to the appropriate handlers. In Go’s ecosystem, developers have numerous router options ranging from the standard library’s http.ServeMux to feature-rich third-party packages.

While functionality and developer experience are important factors when selecting a router, performance characteristics become increasingly critical as applications scale. This is particularly true for high-traffic services or resource-constrained environments.

This article presents benchmark results comparing 16 popular Go HTTP routers, analyzing their performance across different routing scenarios.

Routers Examined

Our benchmarks include the following HTTP routers:

1. Standard Library: net/http.ServeMux - Go’s built-in HTTP router
2. github.com/bmf-san/goblin - A simple trie-based HTTP router
3. github.com/julienschmidt/httprouter - A popular high-performance router based on a radix tree
4. github.com/go-chi/chi - A lightweight, composable router with middleware support
5. github.com/gin-gonic/gin - A full-featured web framework with a router at its core
6. github.com/uptrace/bunrouter - A fast and flexible HTTP router
7. github.com/dimfeld/httptreemux - An adaptation of httprouter with more flexible parameter handling
8. github.com/beego/mux - The router component from the Beego framework
9. github.com/gorilla/mux - A powerful URL router and dispatcher with extensive pattern matching
10. github.com/nissy/bon - A lightweight, fast HTTP router
11. github.com/naoina/denco - An HTTP router that uses a double-array trie
12. github.com/labstack/echo - A high-performance, minimalist framework
13. github.com/gocraft/web - A router focused on middleware and context
14. github.com/vardius/gorouter - A CORS-supporting HTTP router
15. github.com/go-ozzo/ozzo-routing - A fast routing engine from the Ozzo framework
16. github.com/lkeix/techbook13-sample - A sample router implementation

Benchmark Methodology

Test Environment

All benchmarks were run on the following environment:

• Go Version: 1.19
• Operating System: Darwin (macOS)
• Architecture: amd64
• CPU: VirtualApple @ 2.50GHz

Test Cases

Our benchmarks focus on two primary routing scenarios:

1. Static Routes: Fixed URL paths without variables
2. Path Parameter Routes: URLs containing path parameters (e.g., /user/:id)

Static Routes Tests

For static routes, we tested four different path patterns:

• Root: /
• Simple: /foo
• Medium: /foo/bar/baz/qux/quux
• Long: /foo/bar/baz/qux/quux/corge/grault/garply/waldo/fred

These tests evaluate how routers handle paths of increasing length and complexity.

Path Parameter Tests

For routes with path parameters, we tested three patterns with increasing numbers of parameters:

• Single parameter: /foo/:bar
• Five parameters: /foo/:bar/:baz/:qux/:quux/:corge
• Ten parameters: /foo/:bar/:baz/:qux/:quux/:corge/:grault/:garply/:waldo/:fred/:plugh

Since router implementations may use different syntax for path parameters (e.g., :param, {param}, or <param>), the tests account for these differences.

Metrics Measured

For each test case, we measured four key performance metrics:

1. Execution Count (time): Number of function executions completed during the benchmark period. Higher is better.
2. Time per Operation (ns/op): Average time in nanoseconds required per function execution. Lower is better.
3. Memory Allocation (B/op): Average memory allocated in bytes per operation. Lower is better.
4. Allocation Count (allocs/op): Average number of heap allocations per operation. Lower is better.

Benchmark Results

Static Routes Results

Execution Count (time)

Time per Operation (ns/op)

Memory Allocation (B/op)

Allocation Count (allocs/op)

Path Parameter Routes Results

Execution Count (time)

Time per Operation (ns/op)

Memory Allocation (B/op)

Allocation Count (allocs/op)

Analysis and Insights

Static Routes Performance

For static routes, several routers showed exceptional performance:

1. httprouter consistently delivers the best performance across all path lengths. Its execution count is significantly higher than other routers, and its time per operation is the lowest.

2. denco and bon also demonstrate excellent performance characteristics, often within 1.5-2x of httprouter’s speed.

3. gin and bunrouter form the next performance tier, delivering solid results and maintaining consistent performance as path complexity increases.

4. gorillamux and gocraftweb show the least favorable performance for static routes, with the highest time per operation and lowest execution counts.

An interesting observation is how some routers (like beegomux) show significant performance degradation as path length increases, while others (like httprouter, gin, and bunrouter) maintain consistent performance regardless of path complexity.

Path Parameter Performance

When handling routes with path parameters, the performance landscape changes:

1. bunrouter, gin, and echo show excellent performance for single parameter routes, but their performance decreases as parameter count increases.

2. httprouter maintains a strong balance of performance across all parameter counts, showing good scalability.

3. denco and ozzorouting also perform well across the parameter count spectrum.

4. gorillamux and goblin show the most significant performance degradation as parameter count increases.

In most routers, there’s a clear inverse relationship between the number of path parameters and performance. This correlation is expected, as more parameters require more string parsing, variable extraction, and context storing.

Memory Efficiency

Memory efficiency is particularly important in high-throughput applications where router operations occur thousands of times per second:

1. gin, bunrouter, echo, and ozzorouting stand out by achieving zero allocations per operation in all test cases, indicating highly optimized memory usage.

2. httprouter and denco show minimal allocations only for path parameter routes, but none for static routes.

3. gorillamux consistently shows the highest memory allocation and allocation count across all tests, which may impact performance in memory-constrained environments.

The correlation between low memory allocation and high performance is evident in the results, with the best-performing routers generally having fewer allocations.

Data Structure Impact

The internal data structures used by these routers significantly influence their performance:

1. Radix Tree (Patricia Trie): Used by httprouter, gin, echo, chi, and bon. This structure optimizes path matching by sharing common prefixes, resulting in efficient memory usage and fast lookups. The strong performance of these routers demonstrates the effectiveness of this data structure for HTTP routing.

2. Double Array Trie: Implemented by denco, offering compact storage and fast lookups, particularly beneficial for static routes.

3. Standard Trie: Used by goblin, which shows reasonable performance for simple cases but degrades with complexity.

4. Linear Matching: Used by the standard library’s ServeMux, which is surprisingly competitive for simple static routes but lacks support for path parameters.

5. RegExp-based Matching: Some routers use regular expressions for complex patterns, which typically shows poorer performance characteristics.

Choosing the Right Router for Your Application

Based on the benchmark results, here are recommendations for different application scenarios:

High-Performance APIs

For applications where raw routing performance is critical:

1. httprouter offers the best overall performance across both static and parameter-based routes
2. gin provides excellent performance with additional features and zero memory allocations
3. bunrouter is a strong contender, especially for applications with fewer path parameters

Feature-Rich Applications

If you need more functionality beyond basic routing:

1. echo balances good performance with a comprehensive feature set
2. chi offers a middleware-focused approach with reasonable performance
3. gin combines high performance with extensive feature set

Memory-Constrained Environments

For applications running in environments with limited memory:

1. bunrouter, gin, and echo stand out with zero allocations
2. httprouter and denco are also excellent choices with minimal allocations
3. Avoid gorillamux and gocraftweb which have higher memory footprints

Simple Applications

For simpler applications with basic routing needs:

1. The standard library’s ServeMux performs surprisingly well for static routes
2. goblin provides a lightweight alternative with path parameter support
3. bon offers good performance with minimal features

Performance Optimization Strategies

If you’re implementing your own HTTP router or optimizing an existing application, consider these strategies from the best-performing routers:

1. Efficient Data Structures: Utilize specialized tree structures like radix trees or double-array tries that optimize for common prefixes in URL paths.

2. Minimize Allocations: Reduce or eliminate memory allocations in the hot path. Pre-allocate data structures where possible and reuse them across requests.

3. Avoid Regular Expressions: While flexible, regex-based matching tends to be slower than specialized path matching algorithms.

4. Use Fixed-Size Data Structures: When parameters are known in advance, use fixed-size arrays instead of dynamic slices to avoid allocations.

5. Path Normalization: Handle path normalization (like trailing slashes or multiple slashes) during route registration rather than at request time.

6. Parameter Extraction Optimization: Extract path parameters efficiently, preferably without string allocations.

Conclusion

The performance characteristics of HTTP routers in Go vary significantly, with trade-offs between speed, memory efficiency, and features. The benchmarks reveal that:

1. The best-performing routers leverage optimized data structures like radix trees or double-array tries.
2. Performance tends to correlate inversely with memory allocations.
3. There’s often a trade-off between feature richness and raw performance.
4. Some routers maintain consistent performance across different routing scenarios, while others show significant degradation as complexity increases.

While these benchmarks provide valuable insights, it’s important to remember that router performance is just one aspect of overall application performance. In practice, database queries, business logic, and external service calls typically dominate the request processing time.

For most applications, selecting a router with good developer ergonomics that meets your feature requirements will likely be more beneficial than choosing solely based on benchmark results. However, for high-volume services where router performance could become a bottleneck, these benchmarks offer valuable guidance.

Remember that the best router for your application depends on your specific requirements, including performance needs, feature requirements, and development preferences.

References

• Go Router Benchmark Repository
• Go HTTP Router Implementations
• Radix Tree Implementation
• Double-Array Trie
• Go Benchmark Testing Documentation