This repository is a Go SDK and command-line tool for managing Proxmox VE. The core `proxmox` package provides typed configuration structs and client interfaces for nearly every Proxmox resource: QEMU VMs, LXC containers, storage backends, users, groups, pools, API tokens, snapshots, ACME accounts, metric servers, HA rules, SDN, and content templates/ISOs. The SDK maps strongly-typed Go structs to and from Proxmox's `/api2/json` endpoints, with pervasive validation, version-aware feature gates, and both legacy and modern client layers. A Cobra-based CLI in `cli/` exposes these operations to end users, while a deprecated `main.go` still exists for legacy command-line usage.
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 the Builder.io monorepo, a comprehensive headless CMS and visual page builder platform. It provides multi-framework SDKs (React, Angular, Vue, Svelte, Qwik, Solid, React Native, etc.) for fetching and rendering Builder.io content, a plugin ecosystem for extending the visual editor with custom components and data sources (commerce, CMS, media), CLI tools for project scaffolding and space management, and numerous example applications. The core SDK uses Mitosis for code generation to produce framework-specific implementations, and includes features like A/B testing, personalization, localization, visual editing, and server-side rendering. The repository also contains a Gatsby source plugin, a plugin loader, and integration plugins for Shopify, Contentful, Cloudinary, and others. While the codebase is large and actively maintained, it exhibits some technical drift with legacy Gen1 SDKs, duplicated configurations, and outdated dependencies in examples.
box-node-sdk is an official TypeScript client library for the Box Content Cloud API. It is not an application or data research project; it is a generated SDK that wraps Box's REST endpoints with typed schemas, resource managers, authentication flows, and networking. The main entry point is the BoxClient class, which composes managers for files, folders, metadata, webhooks, AI agents, enterprise configurations, and other Box resources. The code is largely auto-generated from Box's OpenAPI specification (see .codegen.json), with every schema file containing typed interfaces and serialize/deserialize functions.
WeRoBot is a Python library for building WeChat Official Account (公众号) robots. It provides a high-level framework that handles message parsing, event routing, signature verification, session management (with multiple backends like SQLite, Redis, MongoDB), message encryption/decryption (AES), and a full client for the WeChat Corporate API (menu management, user management, template messages, mass messaging, etc.). The library can run as a standalone WSGI application (via Bottle) or be integrated into Django, Flask, Bottle, and Tornado. The core robot class (WeRoBot) allows developers to register handlers via decorators for specific message types (text, image, location) and events (subscribe, click, scan). It is a mature, well-documented project with comprehensive test coverage and CI/CD. The codebase is generally well-structured but shows signs of technical drift in dependency versions and Python version support (officially tested up to Python 3.9, some pinned libraries are outdated).
OrbbecSDK is a cross-platform C/C++ software development kit for Orbbec 3D cameras, supporting depth, color, infrared, and IMU sensors. It provides both a high-level Pipeline API for easy stream management and a low-level Device/Sensor API for fine-grained control. The architecture is library-based with a C API (ObSensor.h) and a C++ wrapper (ObSensor.hpp), following a consistent pattern of context creation, device enumeration, stream configuration, frame acquisition, and post-processing via composable filters. Key entry points include Context (device discovery), Pipeline (streaming), Device (property control), and Filter (alignment, point cloud generation, noise removal, etc.). Data flows involve configuring stream profiles, starting the pipeline, receiving frames (depth, color, IR, IMU), applying filters (e.g., depth-to-color alignment, HDR merge, spatial/temporal filtering), and optionally recording or replaying streams. External dependencies include OpenCV for example visualizations, cJSON for multi-device synchronization configuration, and platform-specific USB drivers. The SDK is used in robotics, AR/VR, industrial inspection, and 3D scanning applications.
This repository is a comprehensive .NET SDK for integrating with the WeChat (Weixin) ecosystem, covering Official Accounts (MP), Enterprise WeChat (Work), Mini Programs (WxOpen), Open Platform, and WeChat Pay (TenPay V2/V3). It provides strongly-typed API wrappers for hundreds of WeChat endpoints, message/event handling with a rich class hierarchy, caching abstractions, and utilities for signature verification, encryption, and OAuth. The architecture is a modular monolith with separate packages per platform, sample MVC applications for .NET 4.5/8/10, and dependency injection support via registration modules. Key entry points include static API classes (e.g., `CommonJsonSend.Send<T>()`), message handler base classes, and container-based token management. The SDK also includes experimental components such as an MCP server for AI tool integration and a browser plugin for development assistance. The codebase demonstrates consistent patterns: base result classes with error code handling, container caching with capability flags, extension methods for payment notification decryption, and automatic access token refresh via `ApiHandlerWapper.TryCommonApi`. While the SDK is actively maintained and supports modern .NET versions, it carries some technical debt from legacy .NET 4.x support, duplicated DTOs across platforms, and incomplete test coverage that relies on live credentials. Overall, it is a functional and widely-used SDK (8900+ stars) with solid engineering practices but room for improvement in code consolidation and test automation.
Ndless is a jailbreak and homebrew SDK for TI-Nspire calculators. It enables execution of unsigned ARM-native code and provides a complete development environment including cross-compilation toolchain, system libraries (libndls, libsyscalls), SDL 1.2 port, Lua scripting extensions, and support for multiple calculator models and OS versions (3.x through 6.x). The repository contains exploit-based installers for each OS version, a runtime loader with hooking infrastructure, and a custom executable format (Zehn). The SDK includes sample applications demonstrating graphics, input, particles, networking, and Lua integration. The codebase is heavily based on reverse-engineering of TI's firmware, with hardcoded memory addresses and syscall tables for dozens of OS releases. This is a hybrid project: primarily an application/SDK, but with a significant data/research component in the form of reverse-engineering artifacts (IDA IDC scripts) used to generate syscall mappings.
volc-sdk-python is the official Volcengine SDK for Python, a programmatic client library for Volcengine cloud services. It is not a standalone application: it exposes service classes that wrap REST APIs and protobuf-defined services. The dominant architecture is a base Service class that handles credential resolution (AK/SK, environment variables, ~/.volc/config), request signing, and HTTP dispatch, while each service defines an api_info mapping from action names to HTTP method/path/query. Some services (TLS, Live) use protobuf-generated models; others use legacy ApiInfo-style raw dicts, creating inconsistent implementation styles across the SDK.
This repository is the official Microsoft Azure DevOps Node.js SDK, a client library that provides programmatic access to Azure DevOps Services and Team Foundation Server (TFS) REST APIs. It is not an application itself but a reusable library consumed by Node.js applications (e.g., CI/CD automation, monitoring tools, or custom DevOps integrations). The architecture follows a classic SDK pattern: a central `WebApi` factory class that creates typed API clients for each service area (Build, Git, Test, Work Item Tracking, etc.). All API clients inherit from a common `ClientApiBase` class, use `VsoClient` for version negotiation, and rely on `typed-rest-client` for HTTP transport. The bulk of the codebase is auto-generated from Azure DevOps REST API metadata, resulting in large interface definition files with `TypeInfo` metadata for serialization. Key reusable components include authentication handlers (basic, PAT, bearer, NTLM), rate-limiting utilities, and a chunked upload mechanism for file containers. The library is well-maintained, with ongoing commits, CI pipelines, and sample code demonstrating usage across all major API areas. However, the heavy reliance on generated code and the DO NOT EDIT warnings mean that customizations or fixes must be done upstream.
The GoPro CineForm SDK is a production-grade, wavelet-based video codec library (SMPTE VC-5 super-set) implementing the full CineForm compression pipeline: recursive spatial/temporal wavelet transforms, quantization with rate control, run-length + Huffman entropy coding, and tag/value bitstream framing. It exposes a layered architecture: a C core codec engine (Codec/), high-level EncoderSDK (with asynchronous encoder pools) and DecoderSDK (with thumbnail fast-paths and output format negotiation), plus supporting libraries for color space conversion and scaling (ConvertLib/), geometric mesh warping for GoPro lens correction (WarpLib/), and an Active Metadata engine handling 3D LUTs, CDL color corrections, and timecode. Both encoder and decoder C APIs (CFHD_OpenEncoder/CFHD_EncodeSample, CFHD_OpenDecoder/CFHD_DecodeSample) are the primary integration points, with TestCFHD and WaveletDemo as example tools. The codec is cross-platform (Windows, macOS, Linux) and built with CMake, with a GitHub Actions CI workflow. The codebase is mature and battle-tested in commercial video production, with heavy SIMD (MMX/SSE2) hand-optimization in the wavelet and color conversion paths. However, it carries significant technical debt: large monolithic translation units (e.g., ImageScaler.cpp, DemoasicFrames.cpp with thousands of lines), extensive #ifdef platform conditionals, large blocks of disabled #if 0 code, hardcoded debug paths, and dated SIMD (Pentium 3 MMX) that underutilizes modern AVX-512 hardware. Several latent bugs exist (e.g., a copy-paste index error in ScaleB64ARow), and the FSM/Huffman entropy tables (Common/table17.inc, table18.inc) are checked-in generated artifacts that may silently drift from their generator. Overall it is a strong, working codec with cleanly separable infrastructure components, but the surrounding code style shows its commercial origins and accumulated debt.
This is the Solana.Unity-SDK, a comprehensive Unity package for integrating Solana blockchain functionality into games and applications. It provides multiple wallet connection methods (in-game wallet, Web3Auth social login, Phantom/Solflare deep links, Mobile Wallet Adapter for Android, WebGL browser wallets), transaction signing, NFT minting via Metaplex Candy Machines (including a full editor toolchain for deployment), DEX swap aggregation (Jupiter), domain resolution (.skr), and cross-platform compatibility (Android, iOS, WebGL). The SDK bundles its own async infrastructure (UniTask 2.5.0) and includes sample UI screens for a wallet application. It is architectured around a central Web3 singleton, an abstract WalletBase class with concrete implementations, and platform-specific adapter classes. The codebase is well-structured with clear separation of concerns, but suffers from some monolithic classes (e.g., Web3Auth, CandyMachineController) and reliance on hardcoded endpoints and program IDs. The editor tools are fully functional but tightly coupled to the UnityEditor API. Overall, it is a professional-grade SDK with moderate reusability of its individual components.
This is the OpenIM SDK Core, a cross-platform instant messaging client SDK written in Go. It provides the core messaging functionality—send/receive messages, manage conversations, groups, friends, user profiles, and file uploads—for the OpenIM ecosystem. The SDK communicates with an OpenIM server via HTTP REST and WebSocket long connections, and persists data locally using SQLite (native) or IndexedDB (WebAssembly). It features robust incremental synchronization, a callback-driven architecture for event handling, and extensive support for multiple platforms (iOS, Android, Windows, macOS, Linux, Web). The codebase demonstrates solid engineering practices with generic sync engines, caching utilities, and a comprehensive integration test suite. However, it also contains notable code duplication (dual native/WASM storage implementations), incomplete WASM stubs, some panic-based error handling, and alpha-stage dependencies, which prevent it from being exceptional. Overall, it is a functional, actively maintained SDK with reusable patterns for incremental sync and WebSocket connection management.
This repository serves as the central community hub for the freeRASP mobile security SDK. It does not contain any source code itself; instead, it aggregates platform-specific implementations (Android, iOS, Flutter, React Native, etc.) via Git submodules. The actual security detection logic, integration APIs, and threat monitoring are implemented in the respective submodule repositories. This meta-repo provides documentation, issue tracking, and release coordination across platforms. It is well-maintained with active issue triage and a CI workflow for issue monitoring. The project is licensed under MIT with a fair usage policy.
The C++ REST SDK (cpprestsdk) is a cross-platform, asynchronous C++ library for building cloud-based client-server applications. It provides a comprehensive set of APIs for HTTP client and server communication, JSON parsing and serialization, URI manipulation, WebSocket client support, OAuth 1.0 and 2.0 authentication, and asynchronous stream I/O. The library is built on a custom task-based concurrency model (PPLX) that abstracts platform-specific threading and synchronization, enabling portable async operations across Windows, Linux, macOS, iOS, and Android. The architecture is modular: HTTP client and server implementations use a pipeline stage pattern for middleware (e.g., compression, authentication), and the stream buffer abstraction decouples data sources from I/O operations. The codebase includes extensive functional tests using a bundled UnitTest++ framework, along with sample applications demonstrating real-world usage (BlackJack game, OAuth flows, file search). However, the repository is officially archived and no longer maintained; it exhibits significant technical drift, including deprecated APIs, platform-specific conditional compilation, and dependencies on older library versions (Boost, OpenSSL). Despite this, many components—such as the PPLX task system, URI builder, JSON value, and stream buffers—are well-crafted and could be extracted for reuse in new projects with minimal adaptation.
This repository is the archived reference implementation of the CAI (Cybersecurity AI) framework by Alias Robotics. It is a comprehensive, open-source platform for building and deploying AI-powered offensive and defensive security automation. The codebase provides a full-stack agent framework including a Python SDK (Agent, Runner, tools, handoffs, guardrails, tracing, voice, MCP), a CLI/REPL with rich interactive features, a Textual-based TUI, a FastAPI REST API server, and a benchmarking suite (CAIBench) with cyber ranges and CTF challenges. The framework supports multiple LLM providers (OpenAI, LiteLLM, custom) and includes specialized agents for red teaming, blue teaming, bug bounty, DFIR, network analysis, and more. It also features continuous operations (24/7 autonomous loops), session management, cost tracking, and extensive refusal testing (400+ scenarios). While the repository is now archived and will not receive further updates, the SDK components (function_tool decorator, Handoff abstraction, tracing processors, voice pipeline) are well-crafted and could be extracted for reuse in other agent-based projects. The codebase is large and monolithic, with some global mutable state and test duplication, but overall demonstrates strong engineering practices in the cybersecurity AI domain.
This is the official Alipay SDK for Python, a client library for integrating with Alipay's Open Platform APIs. The repository contains auto-generated domain models, request classes, and response classes that map to hundreds of Alipay API endpoints (payment, finance, marketing, cloud, etc.). The core functionality is in the `DefaultAlipayClient` and `AlipayClientConfig` classes, which handle API signing, request execution, and response parsing. The vast majority of the codebase consists of repetitive, generated boilerplate (35,000+ files) with minimal business logic. The SDK is functional and follows a consistent pattern but lacks tests, is heavily auto-generated, and contains many placeholder/test classes. It is a standard library for developers needing to call Alipay APIs from Python.