Convert Figma logo to code with AI

facundofarias logoawesome-websockets

A curated list of Websocket libraries and resources.

1,578
165
1,578
7
View on GitHub

Top Related Projects

gorilla's avatar

websocket

22,033

Package gorilla/websocket is a fast, well-tested and widely used WebSocket implementation for Go.

websockets's avatar

ws

21,639

Simple to use, blazing fast and thoroughly tested WebSocket client and server for Node.js

uNetworking's avatar

uWebSockets

17,319

Simple, secure & standards compliant web server for the most demanding of applications

socketio's avatar

socket.io

61,034

Realtime application framework (Node.JS server)

theturtle32's avatar

WebSocket-Node

3,748

A WebSocket Implementation for Node.JS (Draft -08 through the final RFC 6455)

novnc's avatar

websockify

3,909

Websockify is a WebSocket to TCP proxy/bridge. This allows a browser to connect to any application/server/service.

Quick Overview

Awesome-websockets is a curated list of WebSocket libraries, tools, and resources. It serves as a comprehensive collection of WebSocket-related projects, frameworks, and educational materials for developers working with real-time web applications.

Pros

  • Extensive collection of WebSocket resources in one place
  • Regularly updated with new and relevant content
  • Well-organized into categories for easy navigation
  • Includes resources for multiple programming languages and platforms

Cons

  • May overwhelm beginners due to the large number of options
  • Some listed projects might become outdated or unmaintained over time
  • Lacks detailed comparisons or recommendations between similar tools
  • Might not cover every niche WebSocket use case or implementation

Note: As this is not a code library but a curated list of resources, the code examples and getting started instructions sections have been omitted.

Competitor Comparisons

gorilla logo

websocket

22,033

Package gorilla/websocket is a fast, well-tested and widely used WebSocket implementation for Go.

Pros of gorilla/websocket

  • Actively maintained and widely used Go WebSocket implementation
  • Provides a robust, production-ready WebSocket library
  • Offers low-level control and customization options

Cons of gorilla/websocket

  • Focused solely on Go, limiting language options
  • Requires more setup and configuration compared to higher-level libraries

Code Comparison

awesome-websockets:

// No code available (curated list of WebSocket resources)

gorilla/websocket:

conn, err := websocket.Upgrade(w, r, nil)
if err != nil {
    log.Println(err)
    return
}
defer conn.Close()

Key Differences

awesome-websockets is a curated list of WebSocket resources, libraries, and tools across various programming languages. It serves as a comprehensive reference for developers seeking WebSocket-related information and implementations.

gorilla/websocket, on the other hand, is a specific WebSocket implementation for Go. It provides a low-level, performant library for building WebSocket applications in Go.

Use Cases

  • awesome-websockets: Ideal for developers looking for WebSocket resources across multiple languages and platforms
  • gorilla/websocket: Best suited for Go developers requiring a robust WebSocket implementation with fine-grained control

Community and Support

awesome-websockets has a broader community contribution due to its nature as a curated list. gorilla/websocket has a more focused community of Go developers and offers more direct support for its specific implementation.

websockets logo

ws

21,639

Simple to use, blazing fast and thoroughly tested WebSocket client and server for Node.js

Pros of ws

  • Actively maintained and widely used WebSocket implementation for Node.js
  • High-performance and lightweight with minimal dependencies
  • Extensive documentation and robust API

Cons of ws

  • Focused solely on WebSocket implementation, not a curated list of resources
  • Requires more setup and configuration for beginners
  • Limited to Node.js environment

Code Comparison

ws:

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', function connection(ws) {
  ws.on('message', function incoming(message) {
    console.log('received: %s', message);
  });
});

awesome-websockets:

No direct code comparison available as awesome-websockets is a curated list,
not a WebSocket implementation.

Summary

ws is a robust WebSocket implementation for Node.js, offering high performance and extensive features. It's ideal for developers who need a reliable WebSocket library for their Node.js projects.

awesome-websockets, on the other hand, is a curated list of WebSocket resources, libraries, and tools. It's beneficial for developers looking to explore various WebSocket options across different languages and platforms.

While ws provides a specific implementation, awesome-websockets offers a broader overview of the WebSocket ecosystem, making it useful for research and discovery of WebSocket-related technologies.

uNetworking logo

uWebSockets

17,319

Simple, secure & standards compliant web server for the most demanding of applications

Pros of uWebSockets

  • High-performance C++ implementation, offering superior speed and efficiency
  • Supports both WebSocket and HTTP protocols
  • Scalable for large-scale applications with low memory footprint

Cons of uWebSockets

  • Requires C++ knowledge for customization and integration
  • Less comprehensive documentation compared to awesome-websockets
  • Focused on a single implementation rather than providing a curated list

Code Comparison

uWebSockets:

uWS::Hub h;
h.onMessage([](uWS::WebSocket<uWS::SERVER> *ws, char *message, size_t length, uWS::OpCode opCode) {
    ws->send(message, length, opCode);
});
h.listen(3000);
h.run();

awesome-websockets: (Note: This is a curated list, not an implementation, so there's no direct code comparison)

Summary

uWebSockets is a high-performance WebSocket and HTTP implementation in C++, focusing on speed and efficiency. It's ideal for developers needing a fast, scalable solution and comfortable with C++.

awesome-websockets is a curated list of WebSocket libraries, tools, and resources across various languages and platforms. It provides a comprehensive overview of available options but doesn't offer a specific implementation.

Choose uWebSockets for performance-critical applications, and refer to awesome-websockets for exploring diverse WebSocket solutions across different languages and use cases.

socketio logo

socket.io

61,034

Realtime application framework (Node.JS server)

Pros of Socket.IO

  • Provides a complete, feature-rich real-time communication framework
  • Offers automatic fallback to long-polling if WebSocket is not available
  • Includes built-in support for rooms, namespaces, and broadcasting

Cons of Socket.IO

  • Heavier and more complex than raw WebSockets
  • May introduce unnecessary overhead for simple use cases
  • Requires both client and server-side Socket.IO libraries

Code Comparison

Socket.IO (server-side):

const io = require('socket.io')(3000);
io.on('connection', (socket) => {
  console.log('A user connected');
  socket.on('chat message', (msg) => {
    io.emit('chat message', msg);
  });
});

Raw WebSocket (server-side):

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 3000 });
wss.on('connection', (ws) => {
  console.log('A user connected');
  ws.on('message', (message) => {
    wss.clients.forEach((client) => client.send(message));
  });
});

Summary

Socket.IO is a comprehensive real-time communication framework, while awesome-websockets is a curated list of WebSocket resources. Socket.IO offers more features and fallback options but comes with added complexity. Raw WebSockets, as showcased in awesome-websockets, provide a lighter, more straightforward approach but require manual implementation of advanced features. The choice between them depends on project requirements and desired level of abstraction.

theturtle32 logo

WebSocket-Node

3,748

A WebSocket Implementation for Node.JS (Draft -08 through the final RFC 6455)

Pros of WebSocket-Node

  • Focused implementation of WebSocket protocol for Node.js
  • Actively maintained with regular updates
  • Comprehensive documentation and examples

Cons of WebSocket-Node

  • Limited to Node.js environment
  • Lacks curated list of WebSocket resources
  • May require additional setup for complex use cases

Code Comparison

WebSocket-Node:

const WebSocketServer = require('websocket').server;
const http = require('http');

const server = http.createServer();
server.listen(8080);

const wsServer = new WebSocketServer({
    httpServer: server
});

Awesome-websockets:

## JavaScript
* [Socket.IO](https://github.com/socketio/socket.io) - Realtime application framework (Node.JS server).
* [SockJS](https://github.com/sockjs/sockjs-client) - WebSocket emulation - Client side.
* [Primus](https://github.com/primus/primus) - An abstraction layer for real-time frameworks to prevent module lock-in.

Summary

WebSocket-Node is a specific implementation for Node.js, offering a focused solution with active maintenance and detailed documentation. However, it's limited to the Node.js environment and may require additional setup for complex scenarios.

Awesome-websockets, on the other hand, is a curated list of WebSocket resources across various languages and platforms. It provides a broader overview of available tools and libraries but doesn't offer a direct implementation.

The code comparison highlights the difference in purpose: WebSocket-Node shows actual implementation code, while Awesome-websockets presents a list of resources in markdown format.

novnc logo

websockify

3,909

Websockify is a WebSocket to TCP proxy/bridge. This allows a browser to connect to any application/server/service.

Pros of websockify

  • Actively maintained project with regular updates and contributions
  • Focused tool for proxying WebSocket connections to TCP sockets
  • Includes built-in support for SSL/TLS encryption

Cons of websockify

  • Limited in scope compared to the broader collection of WebSocket resources
  • Requires more setup and configuration for specific use cases
  • May have a steeper learning curve for beginners

Code Comparison

websockify:

websockify.WebSocketProxy(
    listen_port,
    target_host="localhost",
    target_port=5900,
    ssl_target=False,
    cert=None,
    key=None,
    web=None,
    daemon=False,
    record=None,
    web_auth=False,
    target_cfg=None,
    wrap_mode='exit',
    wrap_cmd=None
)

awesome-websockets:

## Libraries

* [Socket.IO](https://socket.io/)
* [SockJS](https://github.com/sockjs/sockjs-client)
* [Primus](https://github.com/primus/primus)

Summary

websockify is a specialized tool for WebSocket-to-TCP proxying, offering active development and built-in security features. awesome-websockets, on the other hand, serves as a curated list of WebSocket resources, libraries, and tools. While websockify provides a specific solution, awesome-websockets offers a broader overview of the WebSocket ecosystem, making it more suitable for exploration and discovery of various WebSocket-related projects and libraries.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Awesome WebSockets Awesome

A curated list of WebSockets related principles and technologies.

WebSocket is a computer communications protocol, providing full-duplex communication channels over a single TCP connection. The WebSocket protocol was standardized by the IETF as RFC 6455 in 2011, and the WebSocket API in Web IDL is being standardized by the W3C.

Contents

Tools per Language

Agnostic

  • Centrifugo - Scalable real-time messaging in language-agnostic way.
  • Websocketd - WebSockets the UNIX way - Full duplex messaging between web browsers and servers.
  • Nchan - Nchan is a scalable, flexible pub/sub server for the modern web, built as a module for the Nginx web server.
  • Apache-websocket - Apache WebSocket module.
  • MinnowServer - A super small and fast embedded HTTP(S) WebSocket server.
  • gwsocket - Fast, standalone, language-agnostic WebSocket server RFC6455 compliant.

Ballerina

  • Ballerina WebSocket Module - Tailored WebSocket client and server implementations in Ballerina, designed and optimized for seamless integration.

C

  • Libwebsockets - It's a lightweight pure C library built to use minimal CPU and memory resources, and provide fast throughput in both directions as client or server.
  • Libwebsock - C library for easy WebSockets server.
  • Websocket - Websocket server written in C.
  • facil.io - A server/framework library for web applications, including Websockets and native pub/sub.
  • libuwsc - A Lightweight and fully asynchronous WebSocket client C library based on libubox for Embedded Linux.
  • mongoose - Mongoose Embedded Web Server Library - Mongoose is more than an embedded webserver. It is a multi-protocol embedded networking library with functions including TCP, HTTP client and server, WebSocket client and server, MQTT client and broker and much more.
  • WebSockets in C - A minimal implementation for embedded applications.
  • Wslay - Designed to be embedded in other programs; freedom to choose your own network I/O. Event-based API, as well as synchronous frame-based.

C++

  • Websocketpp - C++ Websocket client/server library.
  • QtWebSockets - The QtWebSockets module is an add-on for the Qt5 library.
  • Beast - HTTP and WebSocket built on Boost.Asio in C++11.
  • µWebSockets - Highly scalable WebSocket server library.
  • Simple-WebSocket-Server - A very simple, fast, multithreaded, platform independent WebSocket (WS) and WebSocket Secure (WSS) server and client library implemented using C++11, Boost.Asio and OpenSSL.
  • UEWebsocket - Unreal engine 4 websocket plugin for both c++ and blueprint developer.
  • IXWebSocket - Lightweight C++11 multi-threaded client library with TLS support.
  • LAppS - LAppS - Lua Application Server for micro-services with default communication over WebSockets.
  • libhv - A network library for developing TCP/UDP/SSL/HTTP/WebSocket client/server.

C#

  • ASP.NET SignalR - Incredibly simple real-time web for .NET.
  • WebSocketListener - Lightweight and highly scalable asynchronous WebSocket server for .NET/Mono.
  • websocket-rpc - WebSocket RPC library for .NET with auto JavaScript client code generation, supporting ASP.NET Core.
  • NetGain - A high performance websocket server library powering Stack Overflow.
  • websocket-manager - Real-Time library for ASP .NET Core.
  • WebSockets - Implementation of the WebSocket protocol, along with client and server integration components.
  • WebSockets support in ASP.NET Core - This article explains how to get started with WebSockets in ASP.NET Core.
  • unity-websocket-server - A simple, zero-dependency WebSocket server for Unity.
  • websocket-sharp - A C# implementation of the WebSocket protocol client and server.

Erlang

  • Sockjs-erlang - WebSocket emulation - Erlang server.
  • Cowboy - Small, fast, modular HTTP server written in Erlang.
  • n2o - Erlang web server on websockets.
  • Kraken - Distributed Pubsub Server for Realtime Apps.

Go

  • Gorilla Websocket - WebSocket implementation for Go.
  • Websocket - Package Websocket implements a client and server for the WebSocket protocol as specified in RFC 6455.
  • Ws - Tiny WebSocket library for Go.
  • 1m-go-websockets - Handling 1M websockets connections in Go.
  • gotify/server - A simple server for sending and receiving messages in real-time per web socket.
  • nhooyr/websocket - A minimal and idiomatic WebSocket library for Go.
  • Centrifuge - Real-time messaging library for Go with scalability in mind.

Haskell

  • Websockets - A Haskell library for creating WebSocket-capable servers.
  • n2o - Haskell implementation of Erlang's n2o - web server on websockets.

Java VM

Clojure

  • Sente - Realtime web comms for Clojure/Script.
  • Chord - Library designed to bridge the gap between the triad of CLJ/CLJS, web-sockets and core.async.
  • Luminusweb - Luminus is a Clojure micro-framework based on a set of lightweight libraries.

Java

  • Project Tyrus - JSR 356: Java API for WebSocket - Reference Implementation.
  • Java-WebSocket - Barebones WebSocket client and server implementation written in 100% Java.
  • Atmosphere - Realtime Client Server Framework for the JVM, supporting WebSockets with Cross-Browser Fallbacks.
  • Webbit - Java event based WebSocket and HTTP server.
  • nv-websocket-client - High-quality WebSocket client implementation in Java which.

Kotlin

  • Scarlet - Tinder's Retrofit inspired WebSocket client for Kotlin, Java, and Android

Scala

  • Play - The high velocity web framework for Java and Scala.
  • Finagle-websocket - Finagle Websocket clients and servers.

Julia

  • HTTP.jl - HTTP library for Julia with support on Websockets.
  • WebSockets.jl - A WebSockets library for Julia.

Node.js

  • Socket.IO - Featuring the fastest and most reliable real-time engine.
  • Nodejs-websocket - Node.js module for websocket server and client.
  • WebSocket-Node - WebSocket Implementation for Node.JS (Draft -08 through the final RFC 6455).
  • Sockjs-node - WebSocket emulation - Node.js server.
  • Ws - ws: The fastest cross platform RFC-6455 WebSocket implementation for Node.js.
  • deepstream.io - Open realtime server a fast, secure and scalable realtime server for mobile, web & iot.
  • websocket-as-promised - Promise-based W3C WebSocket wrapper: allows to use promises when connecting, disconnecting and messaging with WebSocket server.
  • faye-websocket-node - Standards-compliant WebSocket client and server.
  • ws-wrapper - Lightweight WebSocket wrapper that provides a socket.io-like event-handler API along with Promise-based requests.
  • ws-server-wrapper - Companion library for ws-wrapper for the server-side.
  • wspromisify - Makes WebSockets async/await ready with a lot of yummies.
  • uws - Tiny WebSockets (access to the C++ library, µWebSockets, via Node.js)
  • netflux - JavaScript client and server side transport API based on WebRTC & WebSocket
  • Sockette - WebSocket client that will automatically reconnect if the connection is lost.
  • rpc-websockets - JSON-RPC 2.0 implementation over WebSockets for Node.js and JavaScript/TypeScript.
  • soketi - Just another simple, fast, and resilient open-source WebSockets server. Built on top of uWebSockets.js.
  • ZilaWS Server - A very easy-to-use and fast WS implementation with async/await eventhandlers and extendable classes.

Perl

PHP

  • Ratchet - Ratchet is a loosely coupled PHP library providing developers with tools to create real time, bi-directional applications between clients and servers over WebSockets.
  • Php-websocket - Simple PHP WebSocket implementation for PHP 5.3.
  • Phpws - PHP Web Socket server.
  • Sandstone - Microframework to build a real time Rest API.
  • Laravel Websockets - A package for Laravel 5.7 and up that will get your application started with WebSockets in no-time!

Python

  • Django Channels - Extends Django with WebSocket, long-poll HTTP, task offloading and other async support.
  • Websockets (code) - Websockets is a library for developing WebSocket servers and clients in Python 3.
  • Ws4py - WebSocket package for Python.
  • Autobahn.ws - Open-source real-time framework for Web, Mobile & Internet of Things.
  • Tornado - Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed.
  • WebSocket Benchmarker - CLI tool for benchmarking WebSocket Servers.
  • Starlette
  • Simple Http Server A simple HTTP server, including support of numerous websocket events like on_text_message, on_binary_message etc. And even on_binary_frame.

Ruby

  • AnyCable - Polyglot replacement for Ruby WebSocket servers with Action Cable protocol.
  • Em-websocket - EventMachine based WebSocket server.
  • Faye-websocket-ruby - Standards-compliant WebSocket client and server.
  • Iodine - WebSocket/HTTP server with integrated pub/sub and optional Redis support.
  • Websocket-driver-ruby - WebSocket protocol handler with pluggable I/O.
  • Websocket-ruby - Universal Ruby library to handle WebSocket protocol.
  • Scorched - Light-weight web framework for Ruby.
  • Firehose - Build realtime Ruby web applications. Created by the fine folks at Poll Everywhere.
  • Slanger - Open Pusher implementation compatible with Pusher libraries.
  • render_sync - Real-time Rails Partials.
  • websocket-rails - Plug and play websocket support for ruby on rails.

Rust

  • Actix - A Rust web framework with support for the Websocket Protocol
  • Websocket Core - Rust Websocket server for periodic message broadcast
  • Tungstenite - Lightweight stream-based WebSocket implementation
  • Tokio-Tungstenite - Tokio binding for Tungstenite, the Lightweight stream-based WebSocket implementation
  • Fastwebsockets - A fast RFC6455 WebSocket server implementation
  • Ratchet - Ratchet is a fast, lightweight and fully asynchronous implementation of the WebSocket protocol with support for extensions and Deflate.
  • wtx - Client and server with encryption support.

Swift

  • Vapor - A high level web framework for Swift.
  • WebsocketKit - A low level WebSocket client library built on SwiftNIO.

Protocols and APIs

GUI Testing Tools

  • Cleora - A native macOS, iOS and iPadOS WebSocket client for testing and documenting APIs.
  • Firecamp - Full-featured GUI WebSocket testing client which helps Dev team to test WebSocket events visually. Test APIs, save them in the project and share it with your team.
  • WebSocket King - A browser based WebSocket testing client that supports multiple simultanious connections, logs of incoming and outgoing messages, custom protocols and multiple projects.
  • Simple WebSocket Client - Simple WebSocket Client (Chrome Extension).

Browser libraries

  • WSGO - like Axios.js, only for WebSocket, adds handy debugging tools
  • ZilaWS Client - A very easy-to-use and fast WS implementation with async/await eventhandlers.

Command-Line Interface (CLI) Tools

  • claws - Awesome WebSocket Client - an interactive command line client for testing websocket servers.
  • wscat - WebSocket cat.
  • wsta - A CLI development tool for WebSocket APIs.
  • ws - websocket command line tool.
  • wssh - wssh ("wish") is a command-line utility/shell for WebSocket inspired by netcat.
  • wsc - A tiny command line websocket client written in Go.
  • ws-cli - WebSocket Command Line Client written in Go.
  • ws-tool - A Develop Tool to Test WebSocket, Socket.IO, Stomp, Bayeux, HTTP, TCP, UDP, WebRTC, DNS API.
  • websocketd - Turn any program that uses STDIN/STDOUT into a WebSocket server. Like inetd, but for WebSockets.
  • websocat - Command-line client for WebSockets, like netcat (or curl) for ws:// with advanced socat-like functions.
  • iola - Socket client with Rest API (WebSocket, Socket.IO, TCP, Unix socket).

Real Life Stories

Security

  • WebSockets - An Introduction - The problems and some security implications of websockets - Cross-site WebSockets Scripting (XSWS).
  • Hacking with WebSockets - Talk on Blackhat USA 2012 Conference.
  • Testing for WebSockets Security Vulnerabilities - Interactive vulnerable WebSocket demos that provide hands-on learning of WebSocket security risks
  • Testing WebSockets - This article is part of the new OWASP Testing Guide v4.
  • Websockets Auth - Journey into WebSockets Authentication/Authorization.
  • WebSocket Security - The WebSocket protocol is a young technology, and brings with it some risks. Decades of experience have taught the web community some best practices around HTTP security, but the security best practices in the WebSocket world aren’t firmly established, and continue to evolve. Nevertheless, some themes have emerged and they are described in this article.
  • Cross-Site WebSocket Hijacking - Cross-Site WebSocket Hijacking (CSWSH) - Web Application Security Blog.

Theory

Articles & Papers

Talks

Tutorials

Books

Sites

License

CC0

Contributing

Please, read the Contribution Guidelines before submitting your suggestion.

Feel free to open an issue or create a pull request with your additions.

Thanks!

Acknowledgments

Table of contents generated with DocToc