websocket

websocket is a minimal and idiomatic WebSocket library for Go.

This is a fork of nhooyr.io/websocket with a few major changes

• not usable from wasm/js
• stripped down go.mod
• removed wspb package
• meant for server-side usage only

Install

go get github.com/fortytw2/websocket

Highlights

• Minimal and idiomatic API
• First class context.Context support
• Fully passes the WebSocket autobahn-testsuite
• Single dependency
• JSON helpers in the wsjson
• Zero alloc reads and writes
• Concurrent writes
• Close handshake
• net.Conn wrapper
• Ping pong API
• RFC 7692 permessage-deflate compression

Roadmap

• HTTP/2 #4

Examples

For a production quality example that demonstrates the complete API, see the echo example.

For a full stack example, see the chat example.

Server

http.HandlerFunc(func (w http.ResponseWriter, r*http.Request) {
c, err:=websocket.Accept(w, r, nil)
iferr!=nil {
// ...
}
deferc.Close(websocket.StatusInternalError, "the sky is falling")
ctx, cancel:=context.WithTimeout(r.Context(), time.Second*10)
defercancel()
varvinterface{}
err=wsjson.Read(ctx, c, &v)
iferr!=nil {
// ...
}
log.Printf("received: %v", v)
c.Close(websocket.StatusNormalClosure, "")
})

Client

ctx, cancel:=context.WithTimeout(context.Background(), time.Minute)
defercancel()
c, _, err:=websocket.Dial(ctx, "ws://localhost:8080", nil)
iferr!=nil {
// ...
}
deferc.Close(websocket.StatusInternalError, "the sky is falling")
err=wsjson.Write(ctx, c, "hi")
iferr!=nil {
// ...
}
c.Close(websocket.StatusNormalClosure, "")

Comparison

gorilla/websocket

Advantages of gorilla/websocket:

• Mature and widely used
• Prepared writes
• Configurable buffer sizes

Advantages of github.com/fortytw2/websocket:

• Minimal and idiomatic API
  • Compare godoc of github.com/fortytw2/websocket with gorilla/websocket side by side.
• net.Conn wrapper
• Zero alloc reads and writes (gorilla/websocket#535)
• Full context.Context support
• Dial uses net/http.Client
  • Will enable easy HTTP/2 support in the future
  • Gorilla writes directly to a net.Conn and so duplicates features of net/http.Client.
• Concurrent writes
• Close handshake (gorilla/websocket#448)
• Idiomatic ping pong API
  • Gorilla requires registering a pong callback before sending a Ping
• Can target Wasm (gorilla/websocket#432)
• Transparent message buffer reuse with wsjson and wspb subpackages
• 1.75x faster WebSocket masking implementation in pure Go
  • Gorilla's implementation is slower and uses unsafe.
• Full permessage-deflate compression extension support
  • Gorilla only supports no context takeover mode
  • We use klauspost/compress for much lower memory usage (gorilla/websocket#203)
• CloseRead helper (gorilla/websocket#492)
• Actively maintained (gorilla/websocket#370)

golang.org/x/net/websocket

golang.org/x/net/websocket is deprecated. See golang/go/issues/18152.

The net.Conn can help in transitioning to github.com/fortytw2/websocket.

gobwas/ws

gobwas/ws has an extremely flexible API that allows it to be used in an event driven style for performance. See the author's blog post.

However when writing idiomatic Go, github.com/fortytw2/websocket will be faster and easier to use.