This repository is a mobile SDK for real-time interactive AI avatars, primarily targeting Android and iOS platforms. It provides on-device inference for speech recognition (via WeNet) and face/body segmentation (via ncnn-based U-Net models), enabling low-latency lip-sync and avatar animation driven by audio input. The SDK is structured as a C++ core with platform-specific wrappers (Java for Android, Objective-C for iOS), and includes bundled third-party libraries (ncnn, OpenCV, FFmpeg, ONNX Runtime) for computer vision, audio processing, and neural network inference. In production, the system ingests 16kHz PCM audio from a microphone, extracts MFCC features, runs streaming speech recognition, and simultaneously processes the audio through a U-Net model to generate facial animation frames. These frames are rendered using OpenGL ES (Android) or Metal (iOS) with alpha blending for compositing onto a background. The SDK also includes model download, encryption (AES-128-CBC), and resource management utilities. The architecture is monolithic: all core logic lives in a single C++ module (duix-sdk), with platform-specific integration code in the app directories. The demo app in Android provides a fully functional test harness. While the SDK is feature-complete and demonstrates significant engineering effort in mobile AI inference, the codebase exhibits several quality issues: duplicated third-party headers across architectures, hardcoded encryption keys, outdated library versions (OpenCV 4.6.0, ncnn 2022/2023), and minimal inline documentation. The high star count and fork activity suggest a strong community, but the code itself is functional rather than exemplar. The most reusable components are the reference-counted memory allocator (dh_mem.h) and the AES stream decryption wrapper (gaes_stream.h), which can be extracted for general-purpose use.
GCViewer is a mature, monolithic Java desktop application (Swing GUI) and CLI tool for parsing, analyzing, and visualizing garbage collection (GC) logs from a wide range of JVM implementations (Sun/Oracle, IBM, HP, BEA/JRockit, Go, and modern OpenJDK unified logging). Its architecture follows a layered pattern: a family of DataReader implementations parse vendor-specific log formats into a unified GCModel of GC events. This model is then consumed by statistical analysis utilities (DoubleData, RegressionLine) and rendered via Swing charts or exported to CSV/PNG/plain text. The codebase demonstrates strong engineering in its utility classes (NumberParser, HttpUrlConnectionHelper, MonitoredBufferedInputStream) and test infrastructure (extensive real-world log fixtures). However, it suffers from significant technical drift, primarily a Java 8 baseline, alongside accumulated technical debt such as e.printStackTrace() usage, ignored tests, known export bugs, and fragile parser logic. It is actively maintained but carries the weight of supporting two decades of JVM GC log formats.
This repository is a lightweight, reference implementation of several standard LLM benchmarks (MMLU, GPQA, MATH, HumanEval, DROP, MGSM, SimpleQA, BrowseComp, HealthBench) developed by OpenAI. It provides a unified evaluation framework based on an `Eval` base class and `SamplerBase` that supports OpenAI Chat Completions API, Anthropic Claude API, OpenAI Responses API, and reasoning models (o1, o3, o4-mini). The main entry point is `simple_evals.py` which accepts command-line arguments to select models and evals, runs them, and outputs HTML reports and JSON metrics. The code is cleanly factored into per-benchmark modules, a shared utility module (`common.py`), and sampler adapters. The framework is designed for reproducibility of OpenAI's published benchmark numbers, with all data loaded from public Azure blob storage URLs. The repository is deprecated as of July 2025 and will not receive updates for new models or benchmarks, though it will continue to host reference implementations for HealthBench, BrowseComp, and SimpleQA.
This repository is an educational tutorial for learning LangChain, LangGraph, and Deep Agents frameworks. It contains two tracks: 101 (fundamentals) and 201 (production patterns) with Jupyter notebooks and standalone agents runnable via `langgraph dev`. The code demonstrates multi-agent supervision, human-in-the-loop interrupts, middleware hooks, MCP tool integration, and a deep research agent with skills and memory. All agents use mock or simulated data (Chinook SQLite, Tavily search) and are designed for learning rather than production. The architecture centers on a centralized model configuration (`utils/models.py`) that supports multiple LLM providers, and reusable patterns like subgraph composition, dynamic prompts, and composite backends. While the code is educational and lacks production hardening (error handling, testing, security), it provides clear, well-commented examples of advanced agent patterns.
This repository is a multi-module Android application that functions as a cheat client for Minecraft Bedrock Edition. It intercepts and modifies network packets between the client and server using a custom relay/proxy (Lunaris) and a comprehensive implementation of the Bedrock protocol (CloudburstMC-derived). The app provides a graphical overlay (Pixie with ImGui) for toggling cheat modules such as flight, speed, killaura, ESP, and more. It also includes Microsoft/Xbox authentication, Discord Rich Presence, and an update check mechanism with native signature verification. Architecture: The project is organized into several Gradle modules: `app` (main Android app with Compose UI and cheat modules), `Protocol/bedrock-codec` (versioned Bedrock packet serializers), `Protocol/bedrock-connection` (Netty-based session management), `Network/transport-raknet` (custom RakNet UDP transport), `Lunaris` (relay/proxy for packet interception), `Pixie` (native C++ overlay with ImGui and Dobby hooking), `minecraft-msftauth` (Microsoft authentication), `lunarisrpc` (Discord RPC), and `animatedux` (Compose UI components). The app uses a packet interception pattern where cheat modules (subclasses of `Element`) override `beforePacketBound` to modify or cancel packets before they are sent to the server. Key entry points: `app` module's `MainActivity` or `LaunchActivity` (Android entry), `Pixie`'s `MuffinService` (overlay service), `Lunaris`'s `LuminaRelaySession` (relay logic), and the protocol codec builders (e.g., `Bedrock_v898`). Data flows: The app connects to a Bedrock server via RakNet, the relay intercepts packets, cheat modules modify them, and the modified packets are forwarded. The protocol library handles serialization/deserialization for dozens of protocol versions. External dependencies: Netty (network), OkHttp (HTTP), Firebase (analytics/crashlytics), Gson (JSON), fastutil (collections), Lombok (Java boilerplate), AndroidX Compose (UI), ImGui (native overlay), Dobby (native hooking), and various Android SDK components.
Phuzz is a research-oriented web application fuzzing framework that orchestrates multiple fuzzers (Burp Suite, Wapiti, WFuzz, ZAP) alongside its own custom fuzzer to detect vulnerabilities in web applications. The repository includes a custom Python-based fuzzer with mutation and scoring modules, a crawler for discovering endpoints, a HAR generator for request capture, and Docker-based orchestration for running fuzzers against vulnerable test applications (bWAPP, DVWA, WackoPicko, XVWA, WordPress plugins). It also contains extensive experimental data and analysis scripts from studies on known and zero-day vulnerabilities, particularly targeting WordPress plugins. The architecture is modular, with separate components for crawling, fuzzing, and result analysis, all containerized via Docker Compose. While primarily a research tool, the core fuzzer and instrumentation components are well-structured and could be extracted for reuse in other security testing pipelines.
PDFQFZ is a Chinese-language Windows Forms desktop application that overlays seal/stamp images onto existing PDFs, including cross-page seam stamps (骑缝章) split across page edges. It supports file/folder batch processing, configurable stamp size/opacity/rotation/placement, white-background transparency removal, PDF password encryption, and optional digital signatures using self-generated or imported PFX certificates. A "merge" mode rasterizes PDF pages at 300 DPI and reconstructs them to flatten content. The app accepts PDF files as command-line arguments and supports drag-and-drop input. The architecture is a single large Form1.cs WinForms monolith for UI and orchestration, with a small Library/ folder of extracted helper classes: a generic PageCache<T> for lazy page preview loading, pure stamp policy predicates, layout calculators, numeric input sanitizers, an async request gate for stale preview cancellation, and an image transparency helper. A separate xUnit test project targets net9.0-windows and compiles linked Library sources to test these helpers, but the main project targets .NET Framework 4.7.2 and is not included in the solution file. The data flow is straightforward: users select source PDFs and a stamp image; pdfGz() iterates files, opens each PDF with iTextSharp PdfReader/PdfStamper, splits the stamp into segments via subImages(), and places them according to seam-stamp mode and position settings. The preview path renders pages lazily through PDFRender4NET at low DPI and uses PageCache plus PreviewOverlayRequestGate to avoid UI hangs on large PDFs. Maintenance is recent and tests exist, but the main application still depends on abandoned/legacy libraries, references an external DLL via an out-of-repo Downloads path, includes committed probe artifacts, and contains a fair amount of monolith-style code debt.
This repository is a comprehensive collection of sample applications for the Microsoft Windows App SDK (WinUI 3). It demonstrates a wide range of platform features including app lifecycle management (activation, instancing, restart, state notifications), scene graph composition (animations, effects, lighting with ExpressionBuilder), notifications (toast, push), widgets, windowing (custom title bars, multi-window), deployment (packaged/unpackaged, self-contained), Windows AI/ML (ONNX inference, AI Foundry APIs like image captioning and text rewriting), text rendering (DWriteCore), printing, camera capture, custom controls, and XAML Islands interop with WinForms/WPF. The samples are provided in multiple languages (C# and C++/WinRT) and target various app models (WinUI 3, WPF, WinForms, console). The codebase is primarily educational—serving as reference implementations—rather than a production library. It suffers from heavy copy-paste duplication across language/framework variants, hardcoded version numbers, and occasional stale references, but includes a few genuinely reusable components such as the ExpressionBuilder fluent animation library and the ImageLoader async surface management system.
ExLlamaV2 is a high-performance inference library for running quantized large language models (LLMs) on consumer GPUs, supporting GPTQ and the custom EXL2 quantization formats. It provides a Python library with custom CUDA/C++ extensions for efficient attention, MLP, sampling, and KV cache management, along with advanced features like dynamic batching, paged attention, speculative decoding, LoRA, tensor parallelism, and multimodal (image/video) support. The library includes a WebSocket server for remote inference and a suite of example scripts demonstrating various use cases. While the codebase exhibits strong engineering with clean abstractions (e.g., module system, filter pattern, multi-backend attention) and highly optimized CUDA kernels, the repository has been archived in favor of ExLlamaV3, meaning no further updates or bug fixes are expected. This makes it a valuable reference for understanding quantized LLM inference internals but risky for new projects requiring ongoing support.
This repository is the official home of the WAMP (Web Application Messaging Protocol) specification, a routed protocol for publish-subscribe and remote procedure calls (RPC) that runs over WebSocket and other transports. It defines the protocol through RFC-style markdown documents (basic and advanced profiles) with detailed message formats, session state machines, authentication schemes (WAMP-CRA, WAMP-Cryptosign, SCRAM, ticket), transport options (RawSocket, batched WebSocket, long-poll), and advanced features like event history, payload passthru mode for E2E encryption, and router-to-router links. The repository also includes a conformance test suite (testsuite/) with machine-readable JSON test vectors covering single messages, sessions, and multi-session scenarios across multiple serializers (JSON, MessagePack, CBOR, UBJSON/BJData, FlatBuffers), along with validation scripts and generators. Additional assets include a catalog of standard WAMP interfaces defined in FlatBuffers IDL (catalog/), governance documents for the WAMP DAO and Swiss association (dao/), and a series of WAMP Enhancement Proposals (WEPs) for future extensions. The codebase is primarily a specification and test infrastructure, not a runnable application. It enforces an AI-assistance disclosure process for contributions (via .audit/) and uses a modern build system with just and uv for generating spec PDFs, documentation, and running tests. The test vector schema (SCHEMA.json) is a standout reusable component: it defines a structured format for message samples, per-serializer byte representations, expected attributes, and per-implementation validation code, enabling cross-language conformance testing. While the specification is comprehensive and the test suite well-organized, many sections remain incomplete (marked 'Write me.', TBD, or 'sketch/alpha'), and there are duplicated working documents in _work/ and binary file artifacts (Visio, OpenDocument) that are hard to review and at risk of drift. The repository shows active maintenance with recent commits and CI workflows, but the unfinished parts and legacy assets lower the overall quality to average.
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.
Dokugen is an AI-powered CLI tool and backend service that automates generation of README files, changelogs, licenses, AI-committed messages, and Open Graph social cards. It operates as a monorepo with TypeScript and Python CLI clients, an Express backend server, a Next.js documentation/marketing site, a VS Code extension, and a Remotion launch video project. The CLI scans a codebase using heuristics and pattern matching to detect project type and framework, then uploads a compressed representation to the server which uses OpenAI (with Vertex AI compatibility) to generate documentation. The system also includes GitHub OAuth device flow authentication, usage tracking via Supabase, and a public leaderboard. Architecturally, the application follows a client-server pattern where the CLI is a thin client that handles file scanning, caching, and compression, while the server manages AI inference, authentication, and telemetry. The server uses Express with middleware for rate limiting, GitHub auth, and response compression. Key reusable components include the file scanning logic with incremental cache and git-ignore integration, GitHub OAuth device flow helper, modular prompt templates for different AI tasks, and a project detection system with a large static pattern table. The project detection logic is duplicated across Python and TypeScript, which introduces maintenance overhead and a known copy-paste bug in the TypeScript version. While primarily an application, Dokugen has data-oriented aspects: the project detection pattern table (150+ frameworks), usage analytics dashboards, and a leaderboard. However, these serve the application's features rather than constituting a data pipeline or research project. The codebase shows active development with frequent releases, but suffers from version drift across packages, hardcoded production values, and some unfinished components (Go client, cacheManager.ts). Overall, it is a functional and well-structured tool with room for improvement in code reuse and consistency.
Ottoman is a Node.js Object-Document Mapper (ODM) for Couchbase, heavily inspired by Mongoose. It provides a schema-driven modeling layer with type validation, hooks, indexes, and a programmatic N1QL query builder. The library abstracts CRUD operations on Couchbase documents, supports distributed ACID transactions, full-text search, and automatic index management (N1QL, View, and RefDoc indexes). It is designed for production use with TypeScript, includes extensive test coverage against a real Couchbase instance, and offers a CLI for scaffolding. The codebase is well-structured but shows signs of stagnation: the last release (2.5.8) is unpublished, dependencies are outdated (Node >=8, couchbase SDK v4, lodash 4.18.1), and the CHANGELOG has not been updated since early 2022. Despite this, the core architecture is solid and the library remains functional for existing Couchbase projects.
WebAudioFont is a browser-based sample synthesis library that plays musical instruments via the Web Audio API using SoundFont (.sf2) presets. It provides a high-level API for scheduling notes, chords, strums, and slides, with built-in effects including a 10-band equalizer, convolution reverb, and compressor. The library also includes a MIDI file parser/player and supports dynamic loading of instrument presets from an external repository. The architecture is a set of standalone TypeScript classes (Player, Loader, Channel, Reverberator, Ticker) that compile into a single browser global. While functional and feature-rich, the codebase shows signs of a personal project: no test suite, hardcoded external URLs, polling-based async loading, and some potential bugs (e.g., incorrect byte reading in MIDIFile.js). The library is GPL-3.0 licensed and has a large catalog of instruments hosted separately.
Jalangi2 is a JavaScript dynamic analysis and instrumentation framework. It instruments JavaScript source code at the AST level using acorn and esotope, inserting calls to a J$ runtime API that dispatches fine-grained callbacks (getField, putField, read, write, functionEnter, scriptEnter, etc.) to pluggable analysis modules. Analyses can observe and even modify concrete execution, and special support exists for symbolic/concolic exploration via J$.readInput and backtracking. It runs in both Node.js and browsers, supports offline instrumentation, and can instrument live web traffic through a mitmproxy-based proxy. The repository is organized as a library with CLI entry points: src/js/commands/jalangi.js for instrument-and-analyze, src/js/commands/instrument.js and esnstrument_cli.js for standalone instrumentation, and src/js/utils/api.js for programmatic use. The runtime core lives in src/js/runtime/analysis.js, with a rich callback template in analysisCallbackTemplate.js. Sample analyses illustrate dlint-style bug detection, coverage, trace writing, shadow memory, and PLDI'16 research analyses. A large corpus of unit tests, browser harnesses, Tizen apps, and benchmarks (SunSpider, Octane) is bundled to validate instrumentation correctness. Maintenance is light and much of the codebase is visibly legacy: ES5-style code, old dependencies (acorn 7.x, jQuery, mitmproxy-based scripts), vendored 2012-era mobile apps, and dated web APIs. The core instrumentation and runtime abstractions remain instructive and partially reusable, but reuse in a modern JavaScript project would require updating dependencies and adapting to current Node/browser environments.
This repository is a production-ready Telegram bot that manages a multi-protocol VPN/proxy server infrastructure deployed via Docker Compose. It supports WireGuard, Xray (VLESS), Shadowsocks, OpenConnect, NaiveProxy, Hysteria, MTProto, and others, plus AdGuard Home for DNS filtering and split tunneling via PAC files. The bot handles user subscriptions, configuration generation, service restarts, IP banning, and automated maintenance (cron, log analysis, backups). The architecture is monolithic: a single large PHP script (app/bot.php ~5000 lines) processes Telegram webhooks and executes commands on Docker containers via SSH. The codebase is functional and actively used (500+ stars) but suffers from lack of tests, tight coupling, hardcoded infrastructure assumptions, and security concerns (Docker socket exposure, SSH in every container). Reusable components are limited, with app/calc.php (CIDR calculation) being a standout isolated utility.
This repository is a Chinese translation and adaptation of the 'CCNA in 60 Days' study guide, organized as an mdBook static site with a companion Tauri desktop application. The primary content consists of 60 daily lessons covering Cisco CCNA exam topics (routing, switching, security, WAN, etc.), each with theory, configuration examples, review questions, and hands-on labs. The desktop app (src-tauri/) provides offline reading, bookmarking, reading progress tracking, and an LLM assistant (Anthropic Claude) for answering questions about the material. The project is hybrid: the vast majority of the repository is documentation, but it also includes a functional application wrapper with CI/CD. While the educational content is thorough and well-structured, the application components are minimal and tightly coupled to the mdBook ecosystem. The repository appears to have been abandoned (last commit with a future date indicates likely clock skew or repository corruption; no recent activity).
EnvyControl is a monolithic Python CLI tool that configures Linux systems for Nvidia Optimus GPU switching between integrated, hybrid (PRIME offload with RTD3), and nvidia-only modes. It directly writes system configuration files (Xorg, modprobe, udev, display manager scripts), runs system commands, and rebuilds initramfs. All logic resides in a single 500+ line script with no modularity, no tests, and no external Python dependencies beyond the standard library. The code is functional but shows signs of organic growth (e.g., hardcoded paths, global constants, mixed concerns in one function). It is widely used (1893 stars) but the original author has stepped back, seeking a new maintainer. The recent commit and open issue count suggest some community maintenance.
This repository is not a software application but a curated knowledge base: 85+ single-file cheatsheets covering programming languages (Bash, Python, Go, Java, C, JavaScript, TypeScript, XML), backend frameworks (Laravel, Django, Express, Node.js, Sails, Adonis), frontend frameworks (React, Vue, Angular, Tailwind, Ember), databases (MySQL, MongoDB, Redis), and developer tools (Git, Docker, Kubernetes, AWS, GCP, Vim, VS Code, FFmpeg, jq). The only executable code is contributor tooling: a commitlint config and a Husky git hook enforcing conventional commit messages. It is consumed by developers copy-pasting commands and syntax references, not by machines. The architecture is flat and static: one reference file per topic organized into languages/, backend/, frontend/, databases/, and tools/ directories, with the README acting as the navigation index. There is no build system, no test suite, no CI, and no runtime entry points. Content quality varies wildly between files: some are comprehensive and well-structured (bash.sh, vue.js, laravel.php, feathers.js), while others are one-liners (macos.sh) or contain typos and malformed formatting. Notable staleness risks include AngularJS, Ember.js, Sails.js, Drush, Nanobox, Laravel 5.8/6.x-era commands, Puppeteer v2.1.1 API references, and a vendored Tailwind v1/v2-era stylesheet, so the repo carries high technical drift despite its active commit history.
This repository is a curated collection of prompt examples for GPT models within the Microsoft Power Platform ecosystem. It contains over 100 prompts organized by product area: AI Builder, Copilot Studio, Power Apps, Power Automate, and Power Pages. Each prompt is stored as a markdown file with accompanying metadata (sample.json) and a README describing its purpose, usage, and authors. The repository does not contain any executable code, libraries, or runtime components; it is purely a reference library of natural language prompts intended to be copied and pasted into Power Platform tools. The prompts range from simple text generation (e.g., anagram creator, blog idea generator) to complex multi-modal analyses (e.g., construction site OSHA compliance, expense processor with receipt images). The repository is well-structured with consistent naming conventions, localization support, and a GitHub Actions workflow to validate sample metadata. While not a software application itself, it serves as a valuable resource for Power Platform developers and citizen integrators looking to leverage GPT capabilities.