Goat alternatives and similar packages
Based on the "Web Frameworks" category.
Alternatively, view Goat alternatives based on common mentions on social networks and blogs.
-
Gin
Gin is a web framework written in Go! It features a martini-like API with much better performance, up to 40 times faster. If you need performance and good productivity. -
go-kit
A Microservice toolkit with support for service discovery, load balancing, pluggable transports, request tracking, etc. -
Iris
High-performance golang web application framework, providing a robust set of features for building modern web applications. -
httprouter
A high performance router. Use this and the standard http handlers to form a very high performance web framework. -
go-socket.io
socket.io library for golang, a realtime application framework. -
Macaron
Macaron is a high productive and modular design web framework in Go. -
Faygo
Faygo uses the new architecture to make itself the most suitable Go Web framework for developping API. Just define a struct Handler, Faygo will automatically bind, verify the request parameters and generate the online API documentation. -
render
Go package for easily rendering JSON, XML, and HTML template responses. -
pat
Sinatra style pattern muxer for Go’s net/http library, by the author of Sinatra. -
REST Layer
A framework to build REST/GraphQL API on top of databases with mostly configuration over code. -
fasthttprouter
A high performance router forked from httprouter. The first router fit for fasthttp. -
tigertonic
A Go framework for building JSON web services inspired by Dropwizard -
Goji
Goji is a minimalistic and flexible HTTP request multiplexer with support for net/context. -
Goyave
Feature-complete REST API framework aimed at clean code and fast development, with powerful built-in functionalities. -
rye
Tiny Go middleware library (with canned Middlewares) that supports JWT, CORS, Statsd, and Go 1.7 context -
httptreemux
High-speed, flexible tree-based HTTP router for Go. Inspiration from httprouter. -
Gearbox
A web framework written in Go with a focus on high performance and memory optimization. -
ozzo-routing
A high-performance HTTP router and Web framework supporting routes with regular expressions. Comes with full support for quickly building a RESTful API application. -
gongular
A fast Go web framework with input mapping/validation and (DI) Dependency Injection
Scout APM - Leading-edge performance monitoring starting at $39/month
Do you think we are missing an alternative of Goat or a related project?
Popular Comparisons
README
:warning: DEPRECATED :warning:
This project is no longer maintained, please use something like gorilla/mux or echo.
Goat

Goat is a minimalistic REST API server in Go. You can pronounce it like the goat, or go-at. Depends on how you like goats.
Contents
Usage
Parameters
You can use named parameters and access them through goat.Params
,
wich you can treat as any map[string]string
.
package main
import (
"net/http"
"github.com/bahlo/goat"
)
func helloHandler(w http.ResponseWriter, r *http.Request, p goat.Params) {
goat.WriteJSON(w, map[string]string{
"hello": p["name"],
})
}
func main() {
r := goat.New()
r.Get("/hello/:name", "hello_url", helloHandler)
r.Run(":8080")
}
Subrouters
You can create subrouters to simplify your code
func main() {
r := goat.New()
r.Get("/hello/:name", "hello_url", helloHandler)
sr := r.Subrouter("/user")
{
sr.Post("/login", "user_login_url", loginHandler)
sr.Get("/logout", "user_logout_url", logoutHandler)
}
r.Run(":8080")
}
Indices
Every route can have a description (like user_login_url
). These can be used
to automagically generate an API index (like this).
If you want to hide specific methods, just provide an empty string.
func main() {
r := goat.New()
r.Get("/", "", r.IndexHandler)
r.Get("/hello/:name", "hello_url", helloHandler)
sr := r.Subrouter("/user")
{
sr.Post("/login", "user_login_url", loginHandler)
sr.Get("/logout", "user_logout_url", logoutHandler)
}
r.Run(":8080")
}
The above example would return the following response on /
:
{
"hello_url": "/hello/:name",
"user_logout_url": "/user/logout"
}
Note: Indices are only supported for GET
requests. Open an issue, if you
want them on other methods, too
Middleware
You can easily include any middleware you like. A great guide to middleware is found here. Important is, that it's in the following format:
func(http.Handler) http.Handler
Example:
func main() {
r := goat.New()
r.Get("/hello/:name", "hello_url", helloHandler)
r.Use(loggerMiddleware, gzipMiddleware)
r.Run(":8080")
}
Wrapping middleware
Sometimes middleware isn't in the required format, so you have to build a
wrapper around it. This example shows a wrapper around
handlers.CombinedLoggingHandler
from the
Gorilla handlers:
func loggerMiddleware(h http.Handler) http.Handler {
// Create logfile (you should check for errors)
f, _ := os.Create("api.log")
return handlers.CombinedLoggingHandler(f, h)
}
You can now safely use the middleware in Goat:
func main() {
r := goat.New()
r.Get("/hello/:name", "hello_url", helloHandler)
r.Use(loggerMiddleware)
r.Run(":8080")
}
Philosophy
I wanted to create a small, fast and reliable REST API server, which supports quick JSON and error output, good rooting and easy-to-use middleware.
I have split the files after responsibility to make it easy for everyone to
dive in (start with goat.go
).
Feedback
If you have problems, feel free to create an issue or drop me an email at [email protected]!
Credits
Thanks to Julien Schmidt for the amazing httprouter used in this project.
License
This project is licensed unter MIT, for more information look into the LICENSE file.
*Note that all licence references and agreements mentioned in the Goat README section above
are relevant to that project's source code only.