ws VS mux

Then take a look at this article - https://www.freecodecamp.org/news/million-websockets-and-go-cc58418460bb/ - using external from Go std lib epoll implementation and https://github.com/gobwas/ws lib it's possible to reduce memory usage per connection drastically. Though keep in mind that this approach is not obvious to implement right and you better to go with STD lib.

Yes, but there are two excelent libs for golang websockets - https://github.com/gobwas/ws - https://github.com/centrifugal/centrifuge

Yes, I find https://github.com/gobwas/ws to be far superior. It has a lot more ability to customize and get high performance as well as a utility package that is much higher level and makes it easy to use. It doesn't have some of the problems of gorilla because they didn't have to support people already depending on it

There's https://github.com/gobwas/ws and https://github.com/nhooyr/websocket but neither have seen a commit in over a year

Oh, thanks! And sorry for still not switching to https://github.com/gobwas/ws :)

Hello, +1 to WebSockets. If you need to choose WS library – go with https://github.com/gorilla/websocket or https://github.com/gobwas/ws. You can also look at Centrifugo server (https://centrifugal.dev/, supports WebSocket, SockJS bidi transports, also EventSource, HTTP-streaming, GRPC unidirectional transports and many builtin features) or https://github.com/centrifugal/centrifuge Go library.

I prefer gobwas/ws because it has the high level "easy mode" (though some things will still be a small learning curve if you are used to REST mostly) and a low level API that you can dive into if you need very high performance and don't mind getting deeply into the details. It has the advantage of being written much after the most popular Gorilla websocket implementation which has some complexity and other issues that it can't totally remove in order to keep compatibility for all of its many users. It's also battle-tested via mail.ru. See A Million Websocket and Go for more details on its inception.

This attention to detail also can mean that for key abstractions in a tool or framework, what concretely goes on doesn't go unexplained. For example, when I was learning Go for web development, my first stumbling block was understanding how interfaces worked, particularly http.Handler, which is key to doing web development with Go's powerful net/http package and the fits-like-a-glove package built on top of it, the Gorilla Mux router. My way of finding out how that worked, and seeing the elegance of that interface, was pretty unorthodox - I figured out how Handlers worked by looking directly at Go's source code (which also is a demonstration of Go's readability, if you're interested in joining the Gophers!). And coming out of that was my very first tech talk at in 2015, on learning Gorilla from its Node.js counterpart, Express.js!

In this ApiGateway implementation, we've employed the Gorilla Mux router for enhanced route handling. Let's break down the key components:

Now that we have set up the Go environment, we can start building our API. The first step is to choose a framework. There are several popular frameworks for building APIs in Go, such as Gorilla mux, Echo, and Gin. For this article, we'll use Gorilla mux.

Mir is a toolkit to develop RESTful API backend service like develop service of gRPC. It adapt some HTTP framework sush as Gin, Chi, Hertz, Echo, Iris, Fiber, Macaron, Mux, httprouter。

My personal favorite tools: - https://github.com/go-kit/ for building services (although it's not necessary a great tool for prototyping) - https://github.com/gorilla/mux router (although it's been recently deprecated, so I'm looking for a similar, maintained library) - https://entgo.io/ ORM - https://watermill.io/ for messaging

We will be using Gorilla Mux to create the APIs locally. Gorilla Mux implements a request router and dispatcher to match the incoming requests.

FYI, Gorilla Mux has been archived. It’s easy to write this without it.