Thousand Island is a pure Elixir, OTP-based socket server library inspired by Ranch. It provides a supervision tree (Server → Listener + AcceptorPoolSupervisor → AcceptorSupervisor → Acceptor/DynamicSupervisor → Handler) that handles TCP and SSL connections with configurable concurrency, connection draining, and shutdown semantics. The library exposes a clean `ThousandIsland.Handler` behaviour for application-level protocol logic, and a `ThousandIsland.Socket` abstraction that decorates underlying transport sockets with automatic telemetry instrumentation. It emits rich telemetry spans for listeners, acceptors, and individual connections, supports suspend/resume of connection acceptance, and handles transient network errors and file descriptor exhaustion without crashing the acceptor tree. The code is thoroughly tested and free of external dependencies beyond telemetry, making it both a production-ready server and an exemplar of idiomatic Elixir/OTP patterns.
This is a multi-platform TypeScript library for programmatically controlling Elgato Stream Deck devices and the Corsair Galleon K100 keyboard. It provides a unified API over three distinct transport layers: USB HID via `node-hid` (Node.js), WebHID (browser), and TCP/IP (network-connected devices like the Stream Deck Studio and Network Dock). The architecture decouples hardware-specific details behind a service-oriented core: `PropertiesService`, `InputService`, `ButtonsLcdDisplayService`, `LcdSegmentDisplayService`, and `EncoderLedService` are injected into a `StreamDeckBase` class, allowing support for 15+ models (Original, Mini, XL, Plus, Plus XL, Neo, Pedal, Studio, etc.) with minimal duplication. Image processing is modular, with pluggable encoders (JPEG, bitmap) and header generators for different firmware generations. The `PreparedBuffer` pattern enables pre-computing and caching of image writes. The codebase is well-structured as a monorepo with separate packages for core logic, Node.js transport, WebHID transport, TCP transport, and a browser demo. Unit tests use Jest with snapshot testing for HID report payloads. The library is actively maintained, with recent commits, CI pipelines, and automated release-please workflows.
HevSocks5Tunnel is a lightweight, high-performance tun2socks proxy written in C. It creates a virtual TUN interface and forwards all TCP/UDP traffic through a SOCKS5 proxy, supporting IPv4/IPv6 dual-stack, UDP-in-UDP and UDP-in-TCP relay modes, optional local ICMP echo replies, and a mapped DNS feature for transparent DNS resolution. The architecture is monolithic but modular: a YAML-based configuration parser, platform-specific tunnel backends (Linux, FreeBSD, macOS, NetBSD, Windows via Wintun), and a session management layer built on top of lwIP and the hev-task-system cooperative multitasking library. It can be used as a standalone CLI tool, a static/shared library, or embedded via JNI on Android. The codebase demonstrates strong C craftsmanship with clean abstractions, efficient I/O patterns (ring buffer with iovec, scatter/gather), and careful platform abstraction.
NATMap is a command-line tool written in C that establishes TCP/UDP port mappings from an ISP NAT public address to a local private address. It uses STUN protocol to discover the mapped public address and maintain NAT bindings through keep-alive sessions. The architecture is built on a cooperative task-based concurrency model (hev-task-system) for efficient non-blocking I/O. It supports two modes: bind mode, where the tool keeps the port alive and notifies the user via a script, and forward mode, where it listens on the mapped port and forwards traffic to an internal target. The codebase is modular, with clear separation of concerns: configuration parsing, socket creation, STUN protocol handling, NAT session keepers (TCP/UDP), port forwarding servers, and script execution. It is highly portable, with cross-compilation support for Linux, Windows, macOS, FreeBSD, and Android across many architectures.
ascii-chat is a production-grade terminal-based video conferencing application that converts live video and audio streams into real-time ASCII art rendered in the terminal. It operates in multiple modes: server (multi-client host), client (connect to server), mirror (local preview), discovery (peer-to-peer session participant), and discovery-service (session registry and NAT traversal relay). The system uses a custom binary protocol (ACIP) over TCP/WebSocket/WebRTC, with end-to-end encryption (Ed25519 + X25519 + XSalsa20-Poly1305) and support for SSH/GPG key authentication. A companion web client compiled via WebAssembly mirrors functionality in the browser. The codebase includes a standalone reusable C library (libasciichat) with a comprehensive platform abstraction layer (POSIX/Windows/WASM), a declarative options registry that auto-generates man pages and shell completions, SIMD-accelerated ASCII rendering (AVX2, NEON, SVE, SSE2), lock-free data structures, and a sophisticated logging system with crash-safe mmap output. The architecture is modular and cross-platform, with extensive unit, integration, and E2E test coverage across Linux, macOS, Windows, and WebAssembly targets.
CIM (Cross-platform Instant Messaging) is a production-grade, modular instant messaging framework built with Java 17, Spring Boot 3.3, and Netty. It provides a complete IM solution including a Netty-based server (cim-server) for handling client connections and message forwarding, a routing server (cim-forward-route) for message routing, user login/offline management, and a client SDK (cim-client-sdk) for building custom clients. The system uses Zookeeper for service discovery, Redis for caching and session management, and optionally MySQL for offline message persistence. It supports group chat, private chat, offline messages, delayed messages, emoji, AI mode, and a built-in command system. The architecture is microservice-oriented with clear separation of concerns, and the codebase demonstrates strong engineering practices including consistent hashing for server selection, a custom ring buffer wheel for delayed tasks, a dynamic HTTP proxy for RPC calls, and a trie-based prefix search. The project includes comprehensive unit and integration tests, Docker support, and CI/CD pipelines.
Lan Mouse is a cross-platform software KVM switch that enables sharing a single mouse and keyboard across multiple computers on a local network, inspired by Apple's Universal Control. It is implemented as a Rust daemon with a GTK4/Libadwaita GUI frontend and a CLI interface, supporting Linux (Wayland, X11), macOS, and Windows. Communication between peers uses DTLS/TLS encryption with self-signed certificate fingerprint authentication over UDP/TCP. Input capture and emulation are abstracted via traits with platform-specific backends (libei, layer-shell, X11, CoreGraphics, Windows input APIs), and client discovery relies on mDNS/DNS. The architecture features a central service orchestrator managing capture, emulation, state, and IPC with the frontend over Unix sockets (or TCP on Windows). The codebase demonstrates solid Rust practices, async patterns with Tokio, and clean trait design for platform abstraction. While functionally complete, there are known caveats around compositor support, scancode mappings, and some memory leaks, reflecting ongoing development effort.
sish is a production-grade, self-hosted SSH reverse tunneling server written in Go. It acts as a multiplexer that accepts SSH connections and forwards HTTP(S), WebSocket, TCP, and TLS (SNI) traffic to local services. Unlike ngrok or serveo, sish requires no custom client—users connect with standard SSH remote port forwarding. The server listens on SSH (default 2222), HTTP (80), and HTTPS (443) ports, and uses unix sockets for internal routing. It supports load balancing, TCP aliases, custom domains via DNS verification, on-demand Let's Encrypt certificates, and a real-time web console for inspecting forwarded requests. The architecture is monolithic but highly concurrent, leveraging goroutines and syncmap for state management. The codebase is well-structured with clear separation of concerns: SSH multiplexing (sshmuxer), HTTP handling (httpmuxer), and shared utilities (utils). It includes integration tests for authentication key requests and connection cleanup. The project is actively maintained with regular releases, CI/CD pipelines, and comprehensive documentation.
iperf3 is a mature, widely-deployed network bandwidth measurement tool developed by ESnet/LBNL. It measures maximum achievable throughput on IP networks using TCP, UDP, and SCTP, and provides detailed per-interval statistics including jitter, packet loss, retransmits, congestion window, and CPU utilization. The tool operates as a client-server application with a control channel for parameter exchange and data channels for bulk transfer, supporting parallel streams, reverse mode, bidirectional tests, and various pacing/affinity options. The codebase is written in C and built with GNU Autotools (autoconf, automake, libtool). It exposes a public library API (libiperf) that allows embedding iperf functionality into other programs, demonstrated by minimal examples in the examples/ directory. The architecture follows a protocol vtable pattern (struct protocol) for pluggable transport protocols, a callback system for test lifecycle events, and a timer subsystem for pacing and reporting intervals. JSON output is generated via a vendored cJSON library. Key strengths include its cross-platform support (Linux, FreeBSD, macOS, and others via #ifdef), extensive command-line options, and integration with perfSONAR for research and education networks. However, the codebase shows signs of organic growth: large monolithic files (iperf_api.c ~3000 lines), platform-specific #ifdef sprawl, manual release test scripts, and some unresolved TODOs. Security advisories have been issued for past vulnerabilities, and the authentication module uses OpenSSL RSA with multiple padding modes. Overall, iperf3 is a high-quality, production-grade tool with a few areas of technical debt.
Packetdrill is a command-line tool for testing TCP/UDP/IP network stacks by scripting precise packet events and system calls. It operates in two modes: local testing via a TUN virtual device, and remote testing over real NICs using a wire server/client protocol. The tool parses a domain-specific language (DSL) with flex/bison, executes events with microsecond timing, and verifies kernel behavior through packet injection, sniffing, and in-script assertions (including TCP_INFO queries). It supports multiple platforms (Linux, FreeBSD, OpenBSD, NetBSD) and protocols (TCP, UDP, ICMP, GRE, MPLS, PSP). The architecture is a single C binary with a modular design: a parser/lexer for test scripts, a run-time engine that manages state (socket, sequence numbers, timestamps), and a network device abstraction layer. Key entry points include `packetdrill.c` (main), `run.c` (script execution), `wire_server.c` (remote testing), and `run_all.py` (test runner). External dependencies are minimal: standard POSIX libraries, optional OpenSSL for PSP, and a YNL submodule for netlink. The test suite consists of hundreds of `.pkt` scripts covering TCP features like fast open, congestion control, SACK, and zerocopy. The codebase demonstrates strong engineering with clean abstractions (vtable for netdev, hash map for timestamp mapping, threading model for blocking syscalls) and deep networking expertise. However, it carries maintenance risks from extensive platform ifdefs, custom kernel header definitions, and tight coupling to specific kernel behaviors. The last commit date (2026-05-14) appears anomalous and may indicate a data error, but the repository shows signs of ongoing development.
Firefly is a high-performance asynchronous networking framework for the JVM, written in Java and Kotlin. It provides a comprehensive set of I/O primitives including HTTP/1.1, HTTP/2, WebSocket (RFC 6455), TCP, and UDP, with both client and server implementations. The framework is designed around Kotlin coroutines and Java NIO2 (AIO), offering non-blocking, backpressure-aware streams and a router-based HTTP server with support for content negotiation, CORS, static file serving, and HTTP/2 upgrade. It also includes built-in SLF4J logging with XML configuration, a JSON serialization service, a WeChat enterprise bot module, and a JNI helper for native code integration. The codebase is modular (firefly-common, firefly-net, firefly-slf4j, firefly-serialization, firefly-wechat, firefly-example) and demonstrates deep protocol-level craftsmanship with custom HPACK, Huffman coding, and state-machine parsers. While primarily a library for building network services, it also serves as a reference implementation for protocol handling on the JVM.
shootback is a reverse TCP tunnel application that enables access to services behind NAT or firewall. It consists of a master server (publicly accessible) and a slaver client (running in the private network). The master listens for slaver connections and client connections, using available slavers to forward client traffic to target services. The architecture uses non-blocking I/O with a socket bridge for efficient data transfer, and a custom control protocol for handshakes and heartbeats. Key components include master.py (main server), slaver.py (client), and common_func.py (shared utilities like SocketBridge and CtrlPkg). The code relies solely on Python's standard library, supporting versions 2.7 and 3.4+. Despite a recent timestamp in metadata, the codebase shows signs of stagnation (e.g., outdated Python version support, lack of recent activity beyond initial development).
This repository contains a collection of example applications demonstrating the use of the gnet networking library in Go. The examples cover various networking paradigms including TCP, UDP, Unix domain sockets, HTTP, WebSocket, and a custom binary protocol. Each example is a standalone program showcasing event-driven connection handling, message parsing, and protocol implementation using gnet's APIs. Key examples include echo servers for different transports, an HTTP server using wildcat for parsing, a push server broadcasting periodic messages, a simple protocol client/server with a custom framing codec, and WebSocket implementations using both gobwas/ws and a custom RFC 6455-compliant codec. The code illustrates gnet's event loop patterns, connection context usage, and efficient I/O handling. While the examples are generally idiomatic and functional, some dependencies show mild technical drift (e.g., the wildcat HTTP parser is outdated). The repository is actively maintained with recent commits and serves as a practical reference for learning gnet-based network programming in Go.
GoBelieveIO/im_service is an instant messaging (IM) server infrastructure implemented in Go. It provides real-time peer-to-peer messaging, group chat (including super groups for large audiences), and chat rooms. The system is designed for clustered deployment and consists of three separate processes: `im` (access server handling client TCP/WebSocket connections), `ims` (storage server using append-only file logs with in-memory indexes), and `imr` (router server coordinating message delivery between access servers). Authentication is token-based (Redis or JWT). Message storage is per-user file-based with efficient offline message synchronization via sync keys. The codebase includes a custom binary protocol over TCP/WebSocket, a Redis-backed pub/sub mechanism for group events and relationship changes, and MySQL for group and friend data. This is a production-grade system (as indicated by its star count) with comprehensive benchmark tools and Python integration tests. However, the repository appears to be in a maintenance-stale state with no recent commits and some deprecated message types.
modbus4j is a Java library implementing the Modbus protocol (ASCII, RTU, TCP, UDP) for industrial automation. It provides both master (client) and slave (server) functionality, supporting standard function codes (read/write coils, discrete inputs, holding/input registers, mask write) and a wide range of data types including BCD, floats, and custom swapped variants. The architecture is modular with separate transport layers, a generic messaging framework (MessageControl, WaitingRoom, Transport), and locator-based high-level access. The library includes a process image simulation for slave devices and batch read capabilities. It was originally developed for Mango Automation and has a parallel Java 1.4 backport (src_cdc) that indicates aging. The codebase shows good separation of concerns and reusable patterns but suffers from technical drift (RXTX dependency, manual byte manipulation, outdated build tools) and lack of modern testing infrastructure.
NSLogger is a remote logging framework for Apple (iOS, macOS, tvOS) and Android platforms. It consists of client libraries (C/Objective-C Swift wrapper for Apple, Java for Android) that send structured log messages (text, binary data, images) over TCP to a desktop viewer application. The desktop viewer (macOS app) provides real-time log viewing with filtering, color coding, search, marks, export, and preference management. An iPad viewer application also exists for on-device log viewing with Core Data persistence and Bluetooth support. The codebase includes multiple Xcode projects for different targets, test apps, and vendored third-party libraries (BWToolkit, HockeySDK-Mac, SSSelectableToolbar). While functional and well-known (4.9k stars), the project shows significant age: manual memory management (non-ARC), duplicated viewer logic across Desktop and iPad, incomplete features (JSON message format stubbed), outdated dependencies, and deprecated API usage. It remains a valuable reference for implementing a custom binary logging protocol and network transport layer, but would require modernization for current platform versions.