This repository is the official documentation for the Binance Spot Exchange APIs. It provides comprehensive specifications for REST, WebSocket, FIX, and SBE (Simple Binary Encoding) protocols, covering trading, market data, account management, and user data streams. The documentation includes detailed endpoint references, authentication methods (HMAC, RSA, Ed25519), order types, filters, error codes, and FAQs. It also contains versioned SBE XML schemas for code generation and lifecycle management JSON files. While not an application itself, it serves as the authoritative reference for developers building trading bots, market-making systems, and integration tools for Binance Spot. The repository is well-structured with bilingual (English/Chinese) support and separate documentation for production, testnet, and demo environments.
This repository is the official JavaScript/TypeScript client SDK for Centrifugo, a scalable real-time messaging server. It provides a robust, event-driven client (Centrifuge class) that manages persistent connections via multiple transports (WebSocket, SSE, HTTP stream, SockJS, WebTransport), handles token-based authentication and subscription authorization, and supports three subscription models: stream (standard channel), map (keyed data), and shared poll (polling with version tracking). The SDK also implements advanced features like automatic reconnection with exponential backoff, recovery from connection drops using offset/epoch, command batching for HTTP transports, and delta compression for efficient updates. The architecture is library-oriented with a clear separation of concerns: transport implementations are abstracted behind a common interface, the main client class manages connection state and dispatch ordering via a serial promise chain, and each subscription type extends a base class with its own state machine (stream, map three-phase, shared poll). The codebase is extensively tested with both unit tests (using a fake server) and integration tests against a real Centrifugo instance in Docker. The SDK is published on npm, supports CJS and ESM builds, and includes protobuf codec support. Notable patterns include a transport abstraction with dependency injection that allows easy addition of new transports, a serial dispatch chain ensuring ordered response processing, and a per-key publish debounce mechanism. The library is actively maintained with ongoing work on refactoring subscription types as documented in NEXT_MAJOR_SUBSCRIPTION_TYPES.md. The repository also demonstrates high craftsmanship in its comprehensive test coverage, graceful error handling, and careful handling of edge cases like stale tokens, network interruptions, and concurrent operations.
This repository provides an ESP-IDF component framework (esp-openclaw-node, esp-openclaw-talk, esp-openclaw-room-node) for building IoT devices that connect to the OpenClaw gateway via WebSocket. It implements device identity (Ed25519), session persistence, command dispatch, and WebRTC audio (Talk). The room-node component adds a full voice-interactive display client with LVGL-based animated face, Canvas (image/A2UI rendering), camera snapshot, file access, and real-time diagnostics. The codebase includes multiple board-specific examples (M5Stack Tab5, Waveshare AMOLED, ESP-BOX-3, M5Stack Dial) that demonstrate reuse of the core components. Strong engineering practices are evident: extensive host-based unit tests (with fake SDK headers), CI pipelines that verify cryptographic signatures and component patches, firmware packaging with provenance manifests, and a component registry release process for versioned distribution. The architecture cleanly separates concerns via board adapter abstractions and config structs, making the core components reusable across different ESP32 hardware.
Neutralinojs is a cross-platform desktop application framework that enables building native desktop apps using web technologies (HTML, CSS, JavaScript) without bundling a full browser engine. The core is a C++ binary that embeds a WebSocket server, a static file server, and a native API layer. Applications communicate with the backend via JSON-RPC over WebSocket, allowing access to OS-level features like file system, process management, clipboard, system info, and window control. The framework supports multiple deployment modes: window (native webview), browser, cloud, and chrome. The architecture is modular, with API controllers in `api/` (e.g., `app`, `fs`, `os`, `net`, `storage`, `clipboard`, `computer`) that each expose a set of methods. The server (`server/neuserver`) routes incoming WebSocket messages to the appropriate controller based on a method prefix. Authentication is handled via a token-based system (`auth/authbasic`), and permissions are enforced through allow/block lists (`auth/permission`). Extensions can be loaded as separate processes (`extensions_loader`), communicating via WebSocket with a shared token. The framework relies heavily on vendored third-party libraries: Asio for async I/O, WebSocket++ for WebSocket protocol, mbedTLS for TLS/crypto, and platform-specific libraries for hardware info, file watching, and clipboard. The build system uses CMake with platform-specific toolchains. The project includes a test suite using Mocha and a custom runner that launches the binary and executes JavaScript specs.
The ultimate-web-scraper repository is a comprehensive PHP toolkit for web scraping and related web interaction tasks. It provides a robust HTTP client (WebBrowser) that handles cookies, redirects, SSL/TLS, and proxy support, enabling reliable web requests. For HTML processing, it includes the TagFilter library, which offers high-performance parsing with CSS3 selector support, streaming capabilities for large files, and built-in XSS prevention. The toolkit also features WebSocket client and server implementations, a simple HTTP server, and utilities for asynchronous operations, DNS over HTTPS, and data streaming. Designed as a modular library, it allows developers to extract and reuse components like the HTTP client, HTML parser, or async helper in other projects with minimal dependencies.
This repository is a mature, production-grade WAMP v2 client library for Node.js and browsers. The actual code implements the Web Application Messaging Protocol with full pub/sub and RPC support over WebSocket, including auto-reconnect, multiple serializers (JSON, CBOR, MsgPack), and authentication methods (ticket, WAMP-CRA, cryptosign). The architecture is modular: a core Wampy class in `src/wampy.ts` accepts pluggable serializers via a common interface, and authentication plugins are registered in a hashmap. The library also includes a CLI tool (`cmd/cli.ts`) for rapid WAMP API debugging. External dependencies are minimal (WebSocket, Node.js crypto for cryptosign). The codebase is written in TypeScript with strict mode, dual ESM/CJS builds, and a comprehensive test suite covering connectivity, PubSub, RPC, and advanced features like progressive calls and Payload PassThru Mode. Despite large test files and some legacy patterns, the code is well-structured and follows promises/async-await throughout.
This repository provides a Ring adapter for Jetty web servers, enabling Clojure/Ring applications to run on Jetty 11 and 12 with support for modern web protocols. Despite its 'jetty9' name, it tracks recent Jetty releases and adds features like HTTP/2, HTTP/3, and WebSocket support that aren't in the official Ring Jetty adapter. The architecture centers around a core adapter that creates and configures Jetty Server instances, with separate implementations for synchronous and asynchronous Ring handlers. It cleanly separates concerns: connection handling (HTTP/HTTPS/HTTP/2/HTTP/3), request/response translation between Jetty and Ring models, and protocol-specific upgrades (WebSocket). The adapter supports virtual threads, SSL/TLS configuration, and serves as a drop-in replacement for the official ring-jetty-adapter while offering more recent Jetty versions and additional features. Notable for its quality implementation are the WebSocket bridge that properly translates between Jetty's WebSocketListener and Ring's WebSocket protocols, and the asynchronous handler implementation that correctly manages the race condition between handler completion and timeout using atomic state and Jetty's scheduling facilities. The optional HTTP/2 and HTTP/3 modules demonstrate good practices for extending the core adapter with dynamically loaded dependencies.
This repository implements a modern Automatic Number Plate Recognition (ANPR) pipeline as a production-ready application. It ingests images (via HTTP upload or WebSocket stream), runs detection using the `fast-alpr` library (YOLO-based ONNX model), performs OCR with `fast-plate-ocr`, applies post-processing (confusion-pair correction, Turkish plate format parsing, temporal majority voting), optionally tracks vehicles via an IoU-based multi-object tracker, and stores only HMAC-SHA256 hashed plate texts for privacy compliance. The system is exposed through a FastAPI REST API with WebSocket support and a HTMX web UI, plus a Typer CLI for inference and server management. It is containerized with Docker and publishes to PyPI and GHCR. The repository also contains a legacy directory (`legacy/`) with a complete YOLOv5 training pipeline for license plate detection, but that code is explicitly unmaintained and serves as historical reference only. The modern codebase is actively maintained, well-tested, and demonstrates strong software engineering practices including protocol-based abstractions, structured logging, Prometheus metrics, and privacy-by-design persistence.
HotGo is a full-stack rapid application development framework built on GoFrame (Go) and Vue 3 (Naive UI). It provides an admin panel with RBAC, multi-tenancy, code generation, plugin/addon system, and integrations for payments (Alipay/WeChat/QQ), SMS, email, file storage (local/S3/MinIO/COS/OSS), message queues (Redis/Kafka/RocketMQ/disk), WebSocket real-time messaging, TCP server with RPC, and cron scheduling. The backend follows a modular service layer with generated DAO/entity patterns and custom ORM handlers for data filtering, tenant isolation, and sorting. The frontend is a dynamic SPA with built-in components for tables, forms, modals, uploads, and charts, plus i18n support. The codebase is production-ready but heavily relies on code generation and custom forks of GoFrame CLI tools, introducing some maintenance risk. Designed primarily for Chinese developers building enterprise admin systems.
MixPHP is a high-performance PHP framework designed for CLI-mode development, supporting multiple server drivers including Swoole, Swow, WorkerMan, PHP-FPM, and the built-in CLI server. The framework is built as a modular monorepo with over 30 independent packages covering HTTP routing (Vega), WebSocket, gRPC, database access, Redis, CLI commands, validation, event dispatching, caching, dependency injection, and microservice infrastructure (service registry, circuit breaker, distributed tracing). The architecture emphasizes coroutine-based concurrency via Swoole, allowing seamless switching between server runtimes with minimal code changes. All components follow PSR standards (PSR-7, PSR-14, PSR-17, PSR-3) and are designed to be used independently, enabling developers to pick only what they need. The framework provides full-stack capabilities for building REST APIs, web applications, WebSocket services, gRPC servers, CLI tools, and microservices. It includes connection pooling for database and Redis, a PSR-14 event dispatcher, a standalone validation library, a generic object pool pattern, and a bean container for dependency injection. Examples and skeleton projects (api, web, cli, grpc, websocket) are provided to accelerate development. The codebase is well-tested with PHPUnit and includes continuous integration via GitHub Actions for splitting the monorepo into individual packages. While the framework is actively maintained and demonstrates strong craftsmanship, some modules show signs of technical drift such as deprecated classes (e.g., FileSystemApplicationContext, legacy cache handlers), reliance on specific Swoole versions, and copied Composer utilities that may diverge over time. The documentation is primarily in Chinese, and the Go counterpart (mix-go/mix) may split community attention.
This repository implements an end-to-end encrypted file transfer system called e2ecp. It consists of a Go-based relay server, a CLI client, and a React web frontend. The system allows users to transfer files or text between peers with zero-knowledge encryption: the relay server never sees plaintext data or metadata. It also supports user accounts with encrypted cloud storage, file sharing via links, device authentication, and email verification. The architecture is a monolith with a WebSocket relay, HTTP API, PostgreSQL database, and separate client implementations. Key entry points are the CLI (main.go), the relay server (src/relay/relay.go), and the React app (web/src/App.jsx). The codebase is well-structured with comprehensive testing, CI/CD, and Docker support. However, there are some maintenance risks such as duplicated protobuf schemas between Go and JavaScript, and the use of a future Go version (1.25) in go.mod, which may indicate dependency drift.
This repository is a production-oriented Go client library for the Binance cryptocurrency exchange, covering spot, margin, USDS-M futures, coin-margined delivery futures, options, portfolio margin, and related products. The code in v2/ exposes fluent builder-style services for REST endpoints and WebSocket streams, with clients such as NewClient, NewFuturesClient, NewDeliveryClient, NewOptionsClient, and portfolio-specific clients. The library is consumed by trading bots and exchange-integration applications; it is not a data analysis or research project, though it provides market-data access primitives for klines, tickers, order books, funding rates, and historical trades.
This is a multi-platform Solana trading bot designed for sniping newly created tokens on pump.fun and letsbonk.fun (Raydium LaunchLab). It listens for token creation events in real-time via multiple mechanisms (gRPC Geyser, WebSocket logs/block subscription, third-party PumpPortal feed), then automatically executes buy and sell trades using program instructions (v2 with full account lists). The codebase emphasizes a platform-agnostic architecture with abstract interfaces for address derivation, instruction building, event parsing, and curve management, allowing new platforms to be added without altering core trading logic. It includes optional 'extreme fast mode' for zero-RPC buys, configurable exit strategies (take-profit, stop-loss, time-based), priority fee management (fixed or dynamic), compute unit optimization, and an interactive cleanup manager. The repository is explicitly educational ('NOT FOR PRODUCTION') and ships with an extensive suite of standalone learning examples and verification scripts that offline-test edge cases such as v1/v2 transaction cutover, optional trailing arguments, price feed failures, and retry bounding. Despite its purpose as a demonstration, the code demonstrates solid engineering practices: abstraction layers, configuration-driven bots, a token bucket rate limiter, plugin-based fee engines, and generic Anchor IDL decoders.
HyperView is a CLI-driven toolkit for downloading TradingView market data, backtesting Python trading strategies with TradingView-parity fill assumptions, and optimizing parameters via Bayesian search (Optuna). The system is organized as a monolith with subcommands: download-data, backtest, hyperopt, pine-optimize, pine-batch-optimize, list-data, list-strategies. It features a pluggable strategy framework with auto-discovery, 20+ TA-Lib indicator wrappers, a backtester that simulates intrabar SL/TP paths, and a two-stage Pine input optimizer that exports optimized Pine scripts with injected best parameters. The codebase is well-structured with dataclasses, type hints, and a rich CLI output using the `rich` library. It includes unit tests for the Pine optimization pipeline and CLI parser. The repository is primarily an application, though it contains data engineering patterns in its downloader and caching layers.
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.
This is the server platform for the XiaoZhi (小智) ESP32 voice-assistant ecosystem: a large multi-component monorepo that turns low-cost ESP32 hardware into an AI voice assistant. The core is a Python asyncio service (main/xiaozhi-server) that maintains WebSocket connections with devices and runs a real-time audio pipeline — VAD, ASR, intent/LLM orchestration, tool calling, and TTS — streaming audio back to the device. Device onboarding, OTA firmware updates, and the WebSocket handshake are partly in the Python server and partly in a Java Spring Boot management API (main/manager-api) backed by MySQL + Redis, which exposes a broad admin surface: users, devices, agents, model-provider configuration (LLM/ASR/TTS/VAD/memory/intent), RAGFlow-backed knowledge bases, voice clone, voiceprint, chat history, and MCP tool management. Two management frontends exist (a Vue 2 web console and a uni-app/Vue 3 mobile app), plus a Live2D digital-human web client and an offline theme generator for firmware assets. It is an application, not a research repository — no notebooks, data pipelines, or analytical datasets; the 'data' features (RAG ingestion, voice cloning, chat-history reporting, performance testers) are all operational application features.
This repository implements an OCPP (Open Charge Point Protocol) server for electric vehicle charging stations, supporting versions 1.6, 2.0, and 2.1. It consists of two main applications: OCPP.Core.Server handles WebSocket-based communication with charging stations and provides a REST API for management operations, while OCPP.Core.Management offers an ASP.NET Core MVC web interface for configuring charge points, managing RFID tags, viewing transactions, and sending remote commands. The system uses Entity Framework Core for data persistence with SQL Server and SQLite providers, featuring a plugin architecture for extensions like custom authorization and Azure Service Bus integration. The codebase demonstrates clean separation of concerns with version-specific controllers, middleware patterns, and dependency injection, though it contains some duplication across OCPP version handlers.
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.
This repository is a collection of standalone example applications demonstrating features of the Gin web framework for Go. It includes over 30 examples covering routing, middleware, authentication, file uploads, WebSocket, server-sent events, gRPC integration, OpenTelemetry, and more. Each example is a self-contained Go program with its own main.go and dependencies. The codebase serves as a learning resource and reference for Gin patterns, but is not a cohesive production system. Many examples are simple and straightforward, though some demonstrate non-trivial patterns like rate limiting, struct-level validation, and concurrent room management.
IRCCloud iOS is a native iOS IRC client that connects to the IRCCloud backend via a custom WebSocket implementation. The app provides real-time chat, file sharing, push notifications, and a rich set of IRC-specific UI components including color formatting, nickname autocomplete, and animated image support. The architecture is a monolithic iOS application with multiple targets (main app, share extension, notification service) and a singleton-based data layer that persists state via NSCoding. The codebase is primarily Objective-C with some Swift and relies on several vendored third-party libraries (TrustKit, FLEX, YYImage, SBJson) for SSL pinning, debugging, image handling, and JSON parsing. Key entry points include the AppDelegate, MainViewController (central UI orchestrator), and NetworkConnection (WebSocket and API singleton). The repository demonstrates solid iOS craftsmanship with reusable IRC-specific utilities but shows technical drift in its use of deprecated iOS APIs and older third-party dependencies.