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.
Nanocl is a distributed container orchestration system designed as a Kubernetes alternative, focusing on simplicity and declarative state management. The system manages workloads termed 'Cargoes' (containers), 'VMs', and 'Jobs' using Docker as the underlying runtime. It features a client-server architecture with a CLI (`nanocl`), a central daemon (`nanocld`), and auxiliary sidecar services for proxying (`ncproxy`) and DNS (`ncdns`). The architecture relies on Rust for performance and safety, utilizing `ntex` for async HTTP handling and `diesel` for database persistence. The core operational model is driven by declarative Statefiles (YAML/TOML/JSON) processed with Liquid templating. These files define the desired infrastructure state, which the daemon reconciles against the actual runtime state. The system integrates directly with the Docker daemon via the `bollard` library to manage container lifecycles, networking, and images. It features a robust event-driven architecture where state changes trigger sidecar updates, such as Nginx configuration regeneration for routing. The codebase demonstrates a modular design with shared crates for error handling, stubs, and utilities. It implements a generic repository pattern for database access and abstract lifecycle traits for resource management. The API is versioned and documented via OpenAPI/Swagger, supporting RESTful CRUD operations and real-time event streaming. While the project shows strong architectural patterns, it carries medium technical drift due to API versioning fragmentation and heavy dependency on Docker API behavior.
Bluebox is a library and agent framework for reverse engineering web applications by monitoring browser interactions via Chrome DevTools Protocol (CDP). It captures network requests, DOM snapshots, storage changes, and user interactions into JSONL files, then uses LLM-driven agents to discover reusable automation routines (parameterized workflows) that can navigate, fetch, click, type, and extract structured data from live websites. The system includes a conversational agent (BlueBoxAgent) that searches a routine index and falls back to an AI browser agent, a GuideAgent for interactive routine creation, and a PrincipalInvestigator orchestrator that runs parallel specialist agents (network, DOM, storage, UI) to build routine catalogs from captured sessions. Architecturally, Bluebox is a modular Python application with clear separation: CDP monitors and session management, Pydantic data models for routines and events, abstract base classes for agents and data loaders, LLM vendor clients (OpenAI, Anthropic), a workspace abstraction for artifact management, and CLI/HTTP entry points. The SDK provides high-level methods (monitor_browser, discover_routine, execute_routine) and the package ships with example routines for real-world sites (Amtrak, Polymarket, Massachusetts corporate search). While primarily an application/library, Bluebox has a strong data pipeline character: it ingests raw CDP events, transforms them through data loaders and vectorstores, and produces structured routine definitions. The benchmark framework evaluates routine quality with deterministic and LLM-based tests. The codebase demonstrates high craftsmanship with reusable patterns (agent tool decorator, workspace abstraction, sandboxed execution, data loader interface) and extensive unit tests, though some specialist agents are marked as beta and the orchestration pipeline is complex.
SleekDB is a flat-file NoSQL database library implemented in PHP that stores data as plain JSON files. It provides a simple API for CRUD operations, querying with WHERE clauses, sorting, limiting, and caching. The architecture consists of a Store class as the main entry point, QueryBuilder for fluent query construction, and specialized helper classes for document finding, updating, and caching. Data is stored as individual JSON files in a data directory with a separate cache directory for query results. The library requires no third-party dependencies beyond PHP 8.4+ with JSON and MBString extensions. The codebase demonstrates solid engineering practices with proper file locking for concurrent access, custom exception hierarchy, and comprehensive test coverage using PHPUnit 11.0. The query builder follows the builder pattern with method chaining. Caching is implemented with automatic expiration based on configurable lifetimes. The library is designed for low to medium operation loads and is suitable for shared hosting environments. Some deprecated methods are marked for removal in version 3.0, indicating active maintenance and refactoring. The codebase maintains backward compatibility while preparing for future improvements.
MTranServer is a high-performance, offline machine translation server that provides a REST API, web UI, and desktop Electron application. It leverages Mozilla's Bergamot (Marian NMT) engine compiled to WebAssembly for on-device translation, with no GPU required and average response times around 50ms. The server supports major world languages, language auto-detection via CLD2 (also compiled to WASM), and offers compatibility endpoints for popular browser translation plugins such as Immersive Translate, DeepL, Google Translate, and Kiss Translator. The architecture is a TypeScript/Node.js monolith using Express with tsoa for typed controllers and Swagger generation, a React frontend with shadcn/ui, and an Electron desktop wrapper. The system includes model auto-downloading, LRU caching, worker-per-language concurrency, and offline mode. The repository contains a large deprecated codebase (Go, Node.js v1, Rust, C++ versions) which is not actively used but remains in the source tree, potentially causing confusion. The active code is well-structured and follows modern TypeScript practices, though some vendored dependencies (CLD2, Bergamot) are old and have been compiled to WASM to mitigate drift.
httpc is a TypeScript framework for building function-based APIs with end-to-end type safety. It abstracts HTTP into typed function calls, providing a server with a middleware pipeline (parsers, rewriters, renderers), a typed client generator that produces proxy-based clients with full autocompletion, a CLI for scaffolding projects and generating clients, and a comprehensive kit (authentication, caching, validation, dependency injection, event bus, permissions, logging, email, geo). The architecture is a monorepo with packages: server, client, kit, cli, and adapters for Vercel, Netlify, and Cloudflare. Key entry points include `createHttpCServer` (server), `createClient` (client), and CLI commands (`create`, `client`, `call`). Data flows: HTTP request → parser → middleware pipeline → call execution → renderer → response. External dependencies include tsyringe, zod, valibot, winston, lru-cache, redis, maxmind, and jws. The framework is experimental (v0.1.0) but demonstrates strong engineering practices with clean abstractions and reusable patterns.
This repository serves as the distribution and documentation hub for the Sage application, a proprietary local AI inference engine. It does not contain the source code of the engine itself, which is distributed as compiled binaries via GitHub Releases. Instead, the repository provides platform-specific installation scripts (PowerShell for Windows, shell for macOS), detailed API documentation, release notes, and legal information. The Sage application enables users to run AI models locally on their machines, exposing OpenAI-compatible and Ollama-native APIs through a local server. The documentation outlines how to interact with the server, including endpoints for chat completions, embeddings, and model management. The installation scripts automate the download and setup process, handling platform-specific considerations such as clearing quarantine flags on macOS and ensuring proper TLS settings for Windows PowerShell. While the repository lacks the application's source code, it maintains high-quality documentation and functional installation scripts that facilitate the deployment and use of the Sage desktop application. The project is actively maintained, with recent updates reflecting new features and platform support.
Integuru is a Python application that reverse-engineers API requests from browser traffic to generate runnable integration code. It takes a HAR file (HTTP archive) containing browser network requests and cookie data, then uses LLMs to analyze these requests to identify which endpoint performs a user-specified action. The system builds a dependency graph to determine what prerequisite requests are needed to gather dynamic parameters (like IDs, tokens), and finally generates Python code that can reproduce the action by making the necessary HTTP requests in the correct order. The architecture uses LangGraph for workflow orchestration, with specialized LLM-powered agents handling different aspects of the analysis (URL identification, dynamic parameter extraction, dependency resolution).
Botdarr is a Java-based chat bot application that integrates with Radarr, Sonarr, and Lidarr media management services, allowing users to search, add, and monitor movies, TV shows, and music via chat platforms (Discord, Slack, Telegram, Matrix). The system uses a monolithic architecture with modular packages: API clients for each media service, command processing, chat platform adapters, and a SQLite database for persistence (e.g., user request limits, callback data). The main entry point is `BotdarrApplication`, which initializes the configured chat client and starts listening for commands. Data flows: user messages are received by the chat client, parsed by `CommandProcessor`, which executes commands that call the media service APIs (via `RadarrApi`, `SonarrApi`, `LidarrApi`), and responses are formatted by platform-specific `ChatClientResponseBuilder` implementations before being sent back. External dependencies include Apache HttpClient, Jackson, JDA (Discord), Slack SDK, Telegram Bot API, Matrix client-server API, and Flyway for database migrations. The codebase demonstrates solid engineering with strategy patterns for lookup/add/downloads, a command pattern for user interactions, and a clean abstraction for chat client response formatting. However, it suffers from technical drift due to reliance on Java 8, outdated libraries (JMockit 1.40, Jackson 2.13.4.1), and manual versioning. The Matrix client support appears incomplete, and response formatting logic is duplicated across platforms, increasing maintenance burden.
UtilMeta is a progressive Python meta-framework for building declarative APIs with integrated ORM, authentication, caching, client generation, and operations monitoring. The codebase provides a modular architecture with backend adaptors for Django, Flask, FastAPI, Sanic, Tornado, and Starlette, allowing developers to write framework-agnostic API services. Core features include declarative API classes with route mounting, request parameter extraction via decorators, automatic OpenAPI spec generation, a plugin system for cross-cutting concerns (CORS, caching, rate limiting), and a full ORM layer that compiles queries to Django/SQLAlchemy/Peewee backends. The ops module offers built-in service monitoring, logging, alerting, and supervisor connectivity for production management. Key entry points are the UtilMeta service class, the API base class, the CLI tool (meta), and the operations configuration. External dependencies include Django, databases libraries, jwcrypto, psutil, and utype for type validation.
This repository contains demonstration scripts and documentation for the GPT_API_free service, a forwarding proxy that provides free access to various large language models including GPT, DeepSeek, Claude, Gemini, and others. The actual forwarding server is not included; instead, the repository offers Python examples using the OpenAI library and standard HTTP requests to illustrate how to interact with the service's API endpoints for chat completions, image generation/editing, audio transcription, speech synthesis, and file analysis. The code is minimal and educational, focusing on replacing the base URL and authentication header to route requests through the proxy. The codebase is primarily a collection of usage examples tightly coupled to the external service's address and API key format. There is no production logic, no tests, and no independent reusable components. The demos follow standard patterns for calling OpenAI-compatible APIs and serve as a quick-start guide for developers integrating the service. As such, the repository does not represent a standalone application but rather a documentation supplement for the GPT_API_free project.
This repository is a production-grade RESTful API service designed to serve Holy Bible text across multiple translations (NVI, RA, KJV, etc.) and languages (Portuguese, English, French, Spanish). Built on a Node.js/Express stack with MongoDB for persistence and Redis for caching and rate limiting, it follows a standard MVC architecture. The system includes JWT-based authentication for user management and request tracking, alongside a static frontend served via Pug templates. While the API contract is well-documented via OpenAPI and Insomnia, the codebase exhibits significant technical debt, specifically regarding cryptographic security (MD5 password hashing) and outdated core dependencies (Jest v24, Mongoose v5). The architecture is functional and modular but relies on legacy frontend technologies (jQuery/Pug) rather than modern SPA frameworks.
Lsky Pro is a self-hosted image hosting platform written in Laravel (PHP). It allows users to upload, store, manage, and share images through a web interface or REST API. The application supports multiple storage backends (local filesystem, AWS S3, Alibaba OSS, Tencent COS, Qiniu Kodo, Upyun USS, SFTP, FTP, WebDAV, MinIO) and offers features such as user groups with granular permissions, image watermarking, content moderation (via third-party scanning services), thumbnail generation, and a public gallery. The frontend uses Blade templates with Alpine.js and jQuery for interactivity, while the backend follows a standard Laravel MVC pattern with services, models, middleware, and enums for configuration management. The codebase is functional but unremarkable from a software craftsmanship perspective. It follows common Laravel conventions without notable innovation. The storage strategy abstraction, enum use, and middleware for feature toggles are decent patterns, but none are isolated enough to be reusable in other projects without significant modification. The JavaScript is heavily reliant on global state and inline jQuery, which reduces testability and maintainability. The project has minimal test coverage (only example tests) and the README explicitly states that the open source version has ceased maintenance. Maintenance is effectively abandoned; the last commit is dated in the future (presumably a metadata error) but the project is marked as no longer supported. Dependencies may be outdated, and the reliance on external cloud SDKs introduces potential compatibility risks. Technical drift is moderate: the application uses Laravel 9 and Tailwind CSS, which are still reasonably current, but the JavaScript dependencies are older and the overall architecture is monolithic. The lack of active development and the explicit deprecation warning make this repository unsuitable for new projects seeking ongoing support, though it could serve as a reference for building a similar image hosting platform.
This repository is a simple Content Management System (CMS) built on the CodeIgniter 3.x PHP framework. It provides basic CRUD operations for news articles organized by channels, user authentication (login/registration), and file uploads via the deprecated Uploadify library. The system includes a REST API for news and authentication, and integrates CKEditor for rich text editing. However, the codebase is severely outdated, relying on deprecated PHP extensions (mysql_, mcrypt), an unmaintained framework version, and obsolete frontend libraries. There are no tests, no modern security practices, and the architecture is a straightforward monolithic MVC with tightly coupled components. It offers limited reuse potential and should be considered a legacy application requiring significant modernization.
This repository is a placeholder for the former Slate API documentation generator. The original code has been removed from GitHub by the author as a protest against Microsoft's contracts with ICE and the IDF. The repository now contains only a README explaining this decision and pointing to an archive. No source code is available for analysis, making it functionally dead. The project was once popular (36k stars) but is now effectively abandoned.