# Using npm
npm install @sw3doo/nano-socket

# Using yarn
yarn add @sw3doo/nano-socket

# Using pnpm
pnpm add @sw3doo/nano-socket

• Node.js: 16.0.0 or higher
• TypeScript: 4.5.0 or higher (for TypeScript projects)
• uWebSockets.js: Included as dependency

import { NanoSocket } from '@sw3doo/nano-socket';

// Create server with configuration
const server = new NanoSocket({
  port: 3000,
  compression: true,
  cors: { origin: '*' }
});

// Handle connections
server.on('connection', (socket) => {
  console.log(`✅ Client connected: ${socket.id}`);
  
  // Send welcome message
  socket.emit('welcome', 'Hello from NanoSocket!');
  
  // Handle messages
  socket.on('message', (data) => {
    console.log('📨 Received:', data);
    socket.emit('echo', data);
  });
  
  // Room management
  socket.on('join-room', (roomName) => {
    socket.join(roomName);
    server.to(roomName).emit('user-joined', socket.id);
    console.log(`🏠 ${socket.id} joined room: ${roomName}`);
  });
});

// Start server
server.listen().then(() => {
  console.log('🚀 NanoSocket server running on port 3000');
});

import { NanoSocketClient } from '@sw3doo/nano-socket';

// Create client with auto-reconnection
const client = new NanoSocketClient('ws://localhost:3000', {
  autoConnect: true,
  reconnection: true,
  reconnectionAttempts: 5,
  reconnectionDelay: 1000
});

// Connection events
client.on('connect', () => {
  console.log('🔗 Connected to server!');
  client.emit('message', 'Hello from client!');
  client.emit('join-room', 'general');
});

client.on('disconnect', (reason) => {
  console.log('❌ Disconnected:', reason);
});

// Message handling
client.on('welcome', (message) => {
  console.log('👋 Welcome:', message);
});

client.on('echo', (data) => {
  console.log('🔄 Echo received:', data);
});

client.on('user-joined', (userId) => {
  console.log(`👤 User ${userId} joined the room`);
});

# Clone the repository
git clone https://github.com/sw3do/nano-socket.git
cd nano-socket

# Install dependencies
npm install

# Build the project
npm run build

# Run server (in one terminal)
npm run test:server

# Run client (in another terminal)
npm run test:client

const server = new NanoSocket(options?: ServerOptions);

ServerOptions:

• port?: number - Server port (default: 3000)
• host?: string - Server host (default: '0.0.0.0')
• compression?: boolean - Enable compression (default: true)
• maxCompressedSize?: number - Max compressed message size (default: 64KB)
• maxBackpressure?: number - Max backpressure (default: 64KB)
• cors?: object - CORS configuration

listen(port?, host?): Promise Starts the server on specified port and host.

use(middleware): NanoSocket Adds middleware function for connection handling.

broadcast(event, ...args): void Broadcasts message to all connected clients.

to(room).emit(event, ...args): void Broadcasts message to all clients in a specific room.

close(): Promise Stops the server and closes all connections.

connectionCount: number Number of currently connected clients.

roomNames: string[] Array of all active room names.

• connection - New client connection
• disconnect - Client disconnection
• listening - Server started listening
• error - Server error
• close - Server closed

const client = new NanoSocketClient(url: string, options?: ClientOptions);

ClientOptions:

• autoConnect?: boolean - Auto-connect on creation (default: true)
• reconnection?: boolean - Enable auto-reconnection (default: true)
• reconnectionAttempts?: number - Max reconnection attempts (default: 5)
• reconnectionDelay?: number - Delay between attempts in ms (default: 1000)
• timeout?: number - Connection timeout in ms (default: 20000)

connect(): Promise Connects to the WebSocket server.

disconnect(): void Disconnects from the server.

emit(event, ...args): boolean Sends message to the server.

on(event, handler): this Registers event handler.

off(event, handler?): this Removes event handler.

once(event, handler): this Registers one-time event handler.

connected: boolean Whether client is connected.

connectionState: ConnectionState Current connection state.

readyState: number WebSocket ready state.

serverUrl: string Server URL.

reconnectionAttempts: number Number of reconnection attempts made.

• connect - Connected to server
• disconnect - Disconnected from server
• connecting - Attempting to connect
• reconnecting - Attempting to reconnect
• reconnect_failed - Failed to reconnect
• error - Connection error

emit(event, ...args): void Sends message to this specific socket.

join(room): void Joins a room.

leave(room): void Leaves a room.

to(room).emit(event, ...args): void Broadcasts to room from this socket.

broadcast(event, ...args): void Broadcasts to all sockets except this one.

disconnect(): void Disconnects this socket.

NanoSocket is built for speed. Here's how it compares:

Benchmarks run on Node.js 18.x, single core, 1KB messages

• uWebSockets.js: Built on the fastest WebSocket implementation
• Zero-copy: Minimal data copying in hot paths
• Efficient serialization: Optimized message handling
• Memory pooling: Reduced garbage collection pressure
• Native performance: C++ bindings for critical operations

┌─────────────────┐    ┌─────────────────┐
│   Application   │    │   Application   │
├─────────────────┤    ├─────────────────┤
│   NanoSocket    │◄──►│ NanoSocketClient│
├─────────────────┤    ├─────────────────┤
│ uWebSockets.js  │    │      ws         │
├─────────────────┤    ├─────────────────┤
│   libuv/epoll   │    │   libuv/epoll   │
└─────────────────┘    └─────────────────┘
     Server Side           Client Side

// Authentication middleware
server.use((socket, next) => {
  const token = socket.handshake.auth.token;
  if (validateToken(token)) {
    socket.userId = getUserId(token);
    next();
  } else {
    next(new Error('Authentication failed'));
  }
});

// Logging middleware
server.use((socket, next) => {
  console.log(`New connection from ${socket.remoteAddress}`);
  next();
});

// Join multiple rooms
socket.join(['room1', 'room2', 'room3']);

// Broadcast to specific rooms
server.to('room1').emit('announcement', 'Hello room1!');
server.to(['room1', 'room2']).emit('multi-room', 'Hello multiple rooms!');

// Broadcast to all except sender
socket.broadcast.emit('message', 'Hello everyone else!');

// Server error handling
server.on('error', (error) => {
  console.error('Server error:', error);
  // Implement your error reporting here
});

// Client error handling
client.on('error', (error) => {
  console.error('Client error:', error);
  // Implement reconnection logic or user notification
});

// Connection-specific error handling
socket.on('error', (error) => {
  console.error(`Socket ${socket.id} error:`, error);
  socket.disconnect();
});

We welcome contributions! Please see our Contributing Guide for details.

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Commit your changes: git commit -m 'Add amazing feature'
4. Push to the branch: git push origin feature/amazing-feature
5. Open a Pull Request

# Clone your fork
git clone https://github.com/sw3do/nano-socket.git
cd nano-socket

# Install dependencies
npm install

# Build and test
npm run build
npm test

See CHANGELOG.md for a detailed history of changes.

This project is licensed under the MIT License - see the LICENSE file for details.

• uWebSockets.js - The fastest WebSocket implementation
• Socket.io - Inspiration for the API design
• TypeScript Community - For excellent tooling and type definitions

• 📖 Documentation: GitHub Wiki
• 🐛 Bug Reports: GitHub Issues
• 💡 Feature Requests: GitHub Issues
• 💬 Discussions: GitHub Discussions

1. Check the documentation
2. Search existing issues
3. Create a new issue with detailed information

id: string Unique socket identifier.

remoteAddress: string Client's remote address.

connected: boolean Whether socket is connected.

joinedRooms: string[] Array of rooms this socket has joined.

server.use((socket, next) => {
  const token = socket.handshake?.auth?.token;
  if (isValidToken(token)) {
    next();
  } else {
    next(new Error('Authentication failed'));
  }
});

server.on('connection', (socket) => {
  socket.on('join-game', (gameId) => {
    socket.join(`game-${gameId}`);
    server.to(`game-${gameId}`).emit('player-joined', {
      playerId: socket.id,
      playerCount: server.rooms.get(`game-${gameId}`)?.size || 0
    });
  });
});

server.on('error', (error) => {
  console.error('Server error:', error);
});

client.on('error', (error) => {
  console.error('Client error:', error);
});

NanoSocket is built on uWebSockets.js, which provides:

• 8x faster than ws library
• 2x faster than socket.io
• Minimal memory usage
• High concurrency support
• Built-in compression

NanoSocket is written in TypeScript and provides comprehensive type definitions:

import { NanoSocket, NanoSocketClient, ServerOptions, ClientOptions } from '@sw3doo/nano-socket';

const server: NanoSocket = new NanoSocket({
  port: 3000,
  compression: true
} as ServerOptions);

Check the examples/ directory for complete implementation examples:

• examples/server.ts - Full server implementation
• examples/client.ts - Full client implementation