EvoNexus is an AI-powered business operating system with a dashboard for managing various applications and services. It has features for managing systems, knowledge base, and user authentication, and uses Docker for containerization.
This repository is a Spring Boot-based demo application for integrating with WeChat Pay APIs. It provides REST endpoints demonstrating various WeChat Pay functionalities including payment processing, refunds, enterprise payments, red packet distribution, and coupon handling for both V2 and V3 versions of the WeChat Pay API. The application uses the WxJava library to handle the actual communication with WeChat's servers. The architecture follows standard Spring Boot MVC patterns with controllers handling HTTP requests, delegating to the WxPayService from WxJava for business logic, and returning formatted responses. Configuration is managed through application.yml using Spring Boot's @ConfigurationProperties, with a dedicated configuration class setting up the WxJava service as a Spring bean. The project includes Swagger for API documentation and basic error handling via custom error pages. While the code demonstrates solid enterprise Java practices with proper dependency injection, configuration separation, and API documentation, it is primarily intended as a learning tool rather than a production-ready library. The controllers contain TODO comments indicating areas where users need to implement their own business logic, and some dependencies (particularly Springfox for Swagger) are outdated relative to current Spring Boot versions.
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.
This repository hosts the documentation and tutorials for Kuboard, a Kubernetes management interface. It is built with VuePress 1.x and serves as a static site via Nginx. The site includes Markdown-based guides covering Kubernetes concepts, Kuboard installation and usage, and practical tutorials for deploying applications. Additionally, it provides version-specific installation scripts for setting up Kubernetes clusters and deploying Kuboard in various configurations (standalone, HA, etc.). The documentation is organized into sections such as Overview, Installation, Learning, Guide, and Support, making it a comprehensive resource for Kubernetes users.
rTorrent is a high-performance BitTorrent client designed for headless (daemon) or ncurses-based terminal use. Its architecture is a monolithic event-driven application with clearly separated subsystems: core download management (libtorrent binding), display abstraction (ncurses windows and stubs), input handling, an extensive RPC layer supporting XMLRPC, JSONRPC, and SCGI, session persistence with async write-back, and a Lua scripting engine. The system exposes hundreds of commands for controlling torrents, trackers, peers, throttles, and DHT. Remote administration is a first-class feature, and the terminal UI is fully customizable via configuration. The codebase is mature and professionally structured, with strong test coverage and well-defined modular boundaries, though it carries some legacy dependencies (autotools, vendored TinyXML2, CppUnit) and deprecated command aliases.
This repository is a Unity-based MMORPG framework that extends the MultiplayerARPG template to support a multi-server architecture with central, map, and database servers. The client provides a full pre-game UI flow (login, registration, server/channel selection, character creation) and in-game features such as guilds, parties, mail, cash shop, gacha, storage, and IAP validation. The server is component-based, with CentralNetworkManager handling authentication and character operations, MapNetworkManager managing per-map gameplay and persistence, and DatabaseNetworkManager abstracting SQLite/MySQL storage. Data flows involve periodic saving of player and building state via data updaters with hash-based change tracking, and caching of social data (parties, guilds) with configurable refresh intervals. External dependencies include LiteNetLib for networking, SQLite/MySQL for databases, and custom ASN.1 parsers for Apple/Google Play receipt validation. The codebase demonstrates modular design through interfaces (IDatabaseClient, IChatProfanityDetector, IIAPReceiptValidator) and reusable utilities (MiniJSON, Asn1Processor).
WebDNN is a browser-based neural network inference engine that executes ONNX models directly on the client side. It provides four backendsโCPU, WebAssembly, WebGL (1/2), and WebGPUโallowing models to run on a wide range of hardware. The repository includes a Python graph transpiler for offline model optimization (shader generation, operator fusion, 8-bit quantization) and a TypeScript runtime with a modular operator registration system. While the runtime is application-oriented (library for web ML inference), the Python transpiler contains research-grade optimization passes and weight compression algorithms, giving the project a hybrid character. The codebase is well-structured with clean abstractions for backends and operators, but some backends (WebGPU, WebAssembly) are partially complete and require specific build toolchains.
This repository is a Nuxt.js 2 module that integrates Sentry error tracking into Nuxt applications. It provides client-side and server-side Sentry initialization, lazy loading, performance tracing, release management, and extensive integration configuration. The module hooks into Nuxt's build process via a custom shim for @nuxt/kit, generating plugin templates and configuring webpack. It supports both JavaScript and TypeScript projects, with options for custom integrations and runtime configuration. The codebase is well-structured with clear separation of concerns (module entry, hooks, options resolution, utilities, templates) and includes a comprehensive test suite using vitest and playwright. However, it is specifically designed for Nuxt 2, which is now deprecated, and the official Sentry Nuxt module is recommended for Nuxt 3+. The repository appears to be in maintenance mode with the last release in September 2024 and no recent commits.
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.
SpaTrackerV2 is a 3D point tracking system that processes video input to estimate camera motion, depth, and track user-selected points in 3D space. It integrates multiple depth estimation models (ZoeDepth, DepthAnything, DepthPro) with a transformer-based tracking architecture, offering both offline (full video) and online (sliding window) processing modes. The system provides a Gradio-based web interface for interactive point selection with SAM assistance and outputs 2D tracking videos, 3D visualizations (HTML), and numerical trajectory data. Evaluation modules support benchmarking against datasets like Sintel and CVO. The codebase demonstrates modular design with reusable components for I/O, geometry, alignment, and visualization, though it relies heavily on specific external models and libraries.
This repository is the source code for the 'Scala็ ไฟฎใใญในใ' (Scala Training Textbook), a comprehensive Japanese-language textbook for learning the Scala programming language. It is not a software application in the traditional sense but a documentation project that produces HTML, PDF, and EPUB versions of the textbook. The content is written in Markdown and processed using HonKit (a GitBook fork) for static site generation, mdoc for compiling and embedding Scala code examples, and textlint for Japanese proofreading. The build system is orchestrated via sbt with custom tasks defined in Scala (e.g., 'textBuildHtml', 'textLint', 'textLinkTest'), which in turn invoke npm-based tools like HonKit and textlint. The project also includes two small example sbt projects under 'src/example_projects/' that demonstrate trait-based dependency injection patterns. Architecturally, the system is a multi-step pipeline: Markdown sources in 'src/' are processed by mdoc to execute Scala code snippets and produce updated Markdown; HonKit then builds the final HTML/EPUB/PDF outputs into the 'honkit/' directory. CI/CD via GitHub Actions automatically runs linting, link checks, compilation of code examples, and deploys the HTML version to GitHub Pages. The repository itself contains no running service or library; its output is a static educational website. Key entry points are the sbt tasks defined in 'build.sbt' and the 'project/' directory, which provide commands for building, linting, and testing. External dependencies include sbt 2.0.9, Scala 3.8.4, HonKit 6.2.2, various npm packages (e.g., textlint, mocha, cheerio), and standard JVM libraries for the example projects (ScalikeJDBC, jBCrypt, ScalaTest). The primary data flow is read-only: authors edit Markdown, reviewers run lint tasks, and CI builds and publishes the textbook.
PhyML is a mature C command-line application for maximum-likelihood phylogenetic inference, with optional Bayesian MCMC dating (PhyTime) and spatial phylogeography (PhyREX) modes. It reads DNA/amino-acid alignments in PHYLIP/NEXUS format, estimates substitution-model parameters, performs NNI/SPR topology searches, computes branch supports (aLRT/SH/aBayes), and outputs Newick/NEXUS trees, site-likelihood files, ancestral sequences, and JSON traces. The code is organized around shared tree/edge/node C structures, a pattern-compressed likelihood engine (lk.c), numerical optimization (optimiz.c), and model-specific modules for molecular clocks, coalescent priors, and spatial diffusion models. The architecture is a monolith of C modules compiled into multiple executables via Autotools conditionals. Main entry points are src/main.c (PhyML), src/date.c (PhyTime), and src/phyrex.c (PhyREX); a command-line interface, interactive menu, and XML configuration are all supported. Optional MPI parallelism, BEAGLE hardware acceleration, and SSE/AVX vectorized likelihood kernels exist. The codebase is research-grade and actively maintained, but carries significant technical debt: heavy #ifdef use, large commented-out experimental blocks, stub functions, hardcoded simulation constants, and no automated test suite. It is a scientific application rather than a data pipeline, though it contains simulation and cross-validation research features. The most safely reusable components are the generic numerical routines: Brent/BFGS optimizers, a dense eigen-solver, and a broad statistical/RNG utility library. These are self-contained C implementations that can be extracted into other numerical projects with minimal modification. Likelihood, tree-search, and spatial-model modules are more tightly coupled to PhyML's internal data structures and are less directly reusable. The project serves as a reference implementation for many phylogenetics algorithms, but its engineering quality varies by module.
skpm is a Sketch Plugin Manager providing a CLI utility to create, build, test, and publish Sketch plugins. It's structured as a monorepo with specialized packages: skpm (main CLI), builder (build/linking), create-sketch-plugin (plugin scaffolding), test-runner (testing framework), and shared utilities. The system handles the full plugin lifecycle from creation to publishing, including webpack/Babel compilation, asset bundling, GitHub integration for releases, and Sketch-specific features like developer mode toggling and log viewing.
LLMMap is a CLI-based automated prompt injection testing framework for LLM-integrated applications, modeled after sqlmap. It systematically discovers injection points (query parameters, headers, body, cookies, path), generates goal-aware adversarial prompts using a dual-LLM architecture (Generator + Judge), and evaluates responses through pattern matching, semantic similarity, and out-of-band callbacks. The tool supports 227 injection techniques across 18 attack families, multiple LLM providers (Ollama, OpenAI, Anthropic, Google), and provides reliability confirmation via Wilson confidence intervals. It includes comprehensive reporting, data-flow tracing, and Burp Suite integration. The codebase is well-structured with clean abstractions, extensive tests, and reusable components, though some modules are reserved for future development and external dependencies like interactsh-client introduce fragility.
TouchTerrain is a web application and standalone tool that converts digital elevation models (DEMs) into 3D-printable terrain models (STL/OBJ). It uses Google Earth Engine as the primary DEM source, with support for local GeoTIFF files. The architecture includes a Flask web server with a frontend using Google Maps and Three.js for preview, a standalone Python script for batch processing, and Jupyter notebooks for interactive use. The core processing pipeline fetches DEM data, resamples it, tiles it, generates mesh geometry with optional walls and bottom, and bundles the output as a ZIP file. The repository also includes geospatial utilities (coordinate conversion, KML parsing, GPX path embossing) and raster cleaning functions. While the codebase is functional and well-documented, it shows signs of technical drift: multiprocessing is broken, JavaScript libraries are outdated (Three.js r71), and there is commented-out code. The project is actively maintained with recent commits and issue triage.
This repository is a Godot GDExtension that enables using Dart as a scripting language for the Godot game engine. It provides a C++ native plugin that embeds the Dart VM, a Dart runtime library (`godot_dart`) with FFI bindings and type wrappers, and a build runner package (`godot_dart_build`) for generating boilerplate code from `@GodotScript` annotations. A binding generator tool (`tools/binding_generator`) reads Godot's extension API JSON to produce Dart bindings for engine classes and built-in types. The repo includes two example projects: a 2D game tutorial and a networking demo. It is feature-rich but explicitly experimental, with partial support for debugging, hot reload, and editor integration, and acknowledges that performance optimization has not yet been performed. The architecture is a hybrid of C++ native extension and Dart packages with code generation pipelines, making it a complex but well-structured integration layer between the Godot engine and the Dart language.
This repository implements a full-stack content operations platform exclusively for Xiaohongshu (XHS), the Chinese social media platform. It provides a complete lifecycle for managing XHS notes: discovering content via search or URL crawling, saving to a local library, AI-assisted rewriting and title/tag generation, scheduling and publishing through XHS's Creator API, and monitoring engagement metrics. The system is built as a modern web application with a FastAPI backend (Python) and a React frontend (TypeScript, Ant Design), using SQLAlchemy for persistence and APScheduler for background job execution. The architecture is a monolith with clear separation of concerns: backend API routers for accounts, notes, drafts, AI, tasks, publishing, monitoring, and analytics; a service layer for business logic; and a set of adapters that encapsulate the reverse-engineered XHS API clients. The frontend provides a dashboard, discovery page, content library, draft editor, publish center, auto-ops scheduler, and analytics views. Authentication uses JWT tokens with refresh logic, and the system supports multiple XHS account types (PC web and Creator) via QR code or phone login. A notable aspect is the extensive reverse-engineering of XHS's anti-bot mechanisms. The codebase includes custom JavaScript modules for generating signatures (b1, MNS, X-S, X-T, websectiga, profileData) and browser fingerprint emulation, all executed locally via Node.js subprocesses. This allows the platform to interact with XHS APIs without a real browser, enabling automated content operations at scale. While the primary focus is on XHS, the platform abstraction layer (PlatformId enum, adapter interfaces) suggests an intention to support other social media platforms, though only XHS is currently implemented. The repository is a hybrid of application and data engineering: it is primarily a production-grade web application with scheduled tasks, user management, and a rich UI, but it also contains data pipeline elements such as crawling, normalization, and storage of XHS content for later analysis. The data models and analytics endpoints provide research-like capabilities (keyword tracking, engagement trends, benchmarks), but these are embedded within the application rather than forming a standalone data research project.
This repository contains documentation and hardware resources for the BIGTREETECH CB1 single-board computer. It does not include executable software but provides comprehensive setup instructions for two system images: a Klipper-based 3D printing firmware and a minimal Armbian Linux system. The documentation covers WiFi configuration, hardware overlays (e.g., WS2812 LED, TFT35 display, MCP2515 CAN bus), eMMC flashing procedures, and detailed GPIO pinout mappings. The repository serves as a reference guide for hardware configuration and system initialization rather than a deployable application.
This repository provides firmware for ESP8266/ESP32 microcontrollers to interface Mitsubishi Heat Pumps (HVAC units) with MQTT and Home Assistant. The firmware runs on the ESP board, which connects to the heat pump's serial interface using the SwiCago/HeatPump library, and exposes a web interface for configuration and control, as well as MQTT topics for integration with smart home systems. It supports Home Assistant MQTT auto-discovery, Prometheus metrics, OTA firmware updates, and multi-language web UI. The architecture is a monolithic Arduino sketch with separate header files for configuration, HTML templates, JavaScript, and language strings. Key entry points are the setup() and loop() functions in mitsubishi2mqtt.ino, which initialize WiFi, MQTT, the heat pump connection, and a web server. Data flows: the ESP reads heat pump status via serial, publishes state to MQTT, subscribes to command topics, and serves a web control panel. External dependencies include the HeatPump library, ArduinoJson, PubSubClient, and the ESP8266/ESP32 Arduino core.
g3nd is the official demo/showcase application for the g3n Go 3D game engine. It is a single Go binary that presents a windowed GUI (built on the engine's own immediate-mode GUI system) with a categorized demo tree. Users select demos that exercise the engine's capabilities: glTF/glb loading, PBR materials, animations (skinning, morph targets), audio (OpenAL), particle systems, post-processing shaders, and GUI widgets (tables, trees, sliders, form boxes, dock layouts). The application registers demos via Go's `init()` side-effect pattern: each demo package imports itself and calls `app.DemoMap["category.name"] = &struct{}{}`. The core `App` struct manages the scene graph, camera, orbit controls, and per-frame `Update` dispatch. The repository also vendors a large set of test assets (glTF sample models, Blender files, audio, textures) under `data/`. The architecture is a classic Go application: `main.go` imports all demo packages for their registration side effects, then delegates to `app.Create().Run()`. The `app` package owns the window, GUI, and demo lifecycle. Each demo implements a minimal `IDemo` interface (`Start`, `Update`, `Cleanup`). The `util` package provides reusable GUI helpers (file selectors, light meshes). The demos are grouped by category: animation, audio, experimental physics, geometry, GUI, light, loader, material, other, shader, texture. The code is idiomatic Go with clean separation, but some demos are marked experimental and the engine dependency is a pseudo-version that may drift.