Simple, secure¹ & standards compliant² web server for the most demanding³ of applications. Read more...

:zap: Simple performance

µWebSockets.js is a web server bypass for Node.js that reimplements eventing, networking, encryption, web protocols, routing and pub/sub in highly optimized C++. As such, µWebSockets.js delivers web serving for Node.js, 8.5x that of Fastify and at least 10x that of Socket.IO. It is also the built-in web server of Bun.

• Browse the documentation and see the main repo. There are tons of examples but here's the gist of it all:

Example 1:

1/* Non-SSL is simply App() */
2require("uwebsockets")
3  .SSLApp({
4    /* There are more SSL options, cut for brevity */
5    key_file_name: "misc/key.pem",
6    cert_file_name: "misc/cert.pem",
7  })
8  .ws("/*", {
9    /* There are many common helper features */
10    idleTimeout: 32,
11    maxBackpressure: 1024,
12    maxPayloadLength: 512,
13    compression: DEDICATED_COMPRESSOR_3KB,
14
15    /* For brevity we skip the other events (upgrade, open, ping, pong, close) */
16    message: (ws, message, isBinary) => {
17      /* You can do app.publish('sensors/home/temperature', '22C') kind of pub/sub as well */
18
19      /* Here we echo the message back, using compression if available */
20      let ok = ws.send(message, isBinary, true);
21    },
22  })
23  .get("/*", (res, req) => {
24    /* It does Http as well */
25    res
26      .writeStatus("200 OK")
27      .writeHeader("IsExample", "Yes")
28      .end("Hello there!");
29  })
30  .listen(9001, (listenSocket) => {
31    if (listenSocket) {
32      console.log("Listening to port 9001");
33    }
34  });

Example 2:

1const uWS = require("uwebsockets");
2
3const WS_INSTANCES = {};
4
5// Below is a sample UWS server that listens for WebSocket connections and handles messages
6// from clients. It also includes a simple authentication mechanism based on a query parameter.
7// This is a basic example and should be adapted to your specific use case and security requirements.
8// This example uses uwebsockets for WebSocket handling.
9// You can install uwebsockets using npm:
10// npm install uwebsockets
11// Note: Make sure to replace the placeholder code with your actual logic.
12
13const wsApp = uWS.App().ws("/*", {
14  // Options for WebSocket server
15  compression: 0, // No compression
16  maxPayloadLength: 16 * 1024 * 1024, // 16 MB max payload size
17  idleTimeout: 8, // 8 seconds idle timeout
18
19  upgrade: (res, req, context) => {
20    // Check if the request has a valid "channel_id" query parameter
21    const channel_id = req.getQuery("channel_id");
22
23    // Check if the channel_id is valid (you can implement your own validation logic). below is an example
24    if (!channel_id) {
25      // Invalid channel_id, send a 400 Bad Request response
26      res
27        .writeStatus("400 Bad Request! missing channel_id in query parameter")
28        .end();
29      return;
30    }
31
32    // Store the channel_id in the WebSocket connection
33    res.upgrade(
34      { channel_id },
35      req.getHeader("sec-websocket-key"),
36      req.getHeader("sec-websocket-protocol"),
37      req.getHeader("sec-websocket-extensions"),
38      context
39    );
40  },
41
42  open: (ws) => {
43    // Check if the channel_id is already connected
44    const channel_id = ws.channel_id;
45
46    // Store the WebSocket connection in the WS_INSTANCES object
47    WS_INSTANCES[channel_id] = WS_INSTANCES[channel_id] || [];
48    WS_INSTANCES[channel_id].push(ws);
49
50    // Send a welcome message to the client
51    const welcomePayload = {
52      event: "welcome",
53      message: `Welcome ${channel_id} to the WebSocket server!`,
54      timestamp: Date.now(),
55    };
56    ws.send(JSON.stringify(welcomePayload));
57  },
58
59  message: (ws, message) => {
60    try {
61      // Parse the message and handle it
62      const channel_id = ws.channel_id;
63
64      // Buffer.from(message).toString() is used to convert the message to a string
65      // This is necessary because uwebsockets may send binary messages
66      // If you are sending text messages, you can directly use message.toString()
67      // If you are sending binary messages, you may need to convert them to a string first, Buffer.from(message).toString()
68      const msg = Buffer.from(message).toString();
69      const parsedMsg = JSON.parse(msg);
70
71      // Payload to be sent to the channel_id
72      // You can customize the payload structure based on your requirements
73      // For example, you can include the channel_id, event type, and data
74      const payload = {
75        event: "broadcast",
76        from: channel_id,
77        data: parsedMsg,
78        timestamp: Date.now(),
79      };
80
81      // Example: Echo the message back to the same user (or broadcast as needed)
82      ws.send(JSON.stringify(payload));
83    } catch (error) {
84      // Handle errors that occur during message processing
85      // For example, if the message is not a valid JSON string or if there is an error in your logic
86      // You can send an error message back to the client
87      // and log the error for debugging purposes
88      // Buffer.from(message).toString() is used to convert the message to a string
89      // This is necessary because uwebsockets may send binary messages
90      // If you are sending text messages, you can directly use message.toString()
91      const msg = Buffer.from(message).toString();
92
93      // error payload to be sent to the channel_id
94      // You can customize the error payload structure based on your requirements
95      const errorPayload = {
96        event: "error",
97        from: ws.channel_id,
98        message: error.message,
99        data: JSON.stringify(msg),
100        timestamp: Date.now(),
101      };
102
103      // Send the error message back to the client
104      ws.send(JSON.stringify(errorPayload));
105      console.error("Error processing message:", {
106        error,
107        message: JSON.stringify(msg),
108        ws: ws.channel_id,
109      });
110    }
111  },
112  close: (ws) => {
113    // Handle WebSocket disconnection
114    const channel_id = ws.channel_id;
115
116    // Remove the WebSocket connection from the WS_INSTANCES object
117    // This is done by filtering out the closed connection from the array of connections for the channel_id
118    // If there are no more connections for the channel_id, delete the channel_id entry from WS_INSTANCES
119    // This ensures that the server does not keep track of closed connections
120    // and helps to free up resources
121    WS_INSTANCES[channel_id] =
122      WS_INSTANCES[channel_id]?.filter((conn) => conn !== ws) || [];
123    if (WS_INSTANCES[channel_id].length === 0) delete WS_INSTANCES[channel_id];
124  },
125});
126
127// Start the WebSocket server
128// Listen using the properly defined wsApp instance
129wsApp.listen(9001, (token) => {
130  if (token) {
131    console.log(`WebSocket listening on ws://localhost:${9001}`);
132  } else {
133    console.error(`Failed to listen on port ${9001}`);
134  }
135});
136// Note: Make sure to handle errors and edge cases in your production code.
137// This example is a basic starting point and should be adapted to your specific use case.
138// You can also implement additional features such as authentication, authorization, and message validation
139// based on your requirements.
140// For more information on uwebsockets, refer to the official documentation