Botright is a Python library built on Playwright that provides advanced browser automation with stealth features to evade bot detection. It includes proxy management, fingerprint spoofing using real browser profiles (chrome-fingerprints), human-like mouse movements, and CAPTCHA solving for hCaptcha, reCAPTCHA, and Geetest (though Geetest support is currently disabled). The library wraps Playwright's API with a custom layer that intercepts browser events, modifies user agent, platform, and other fingerprinting vectors, and injects anti-detection scripts. It supports both headless and headed modes, proxy rotation, and response caching. The codebase is well-structured but has commented-out modules indicating incomplete transitions (e.g., Geetest).
GraphvizOnline is a client-side Single Page Application (SPA) designed for editing and rendering Graphviz DOT language diagrams directly within the browser. The architecture is purely frontend, utilizing the Ace Editor library for syntax highlighting and `viz.js` (Graphviz compiled to JavaScript/WebAssembly) for rendering. The application manages state via URL parameters and hash fragments, enabling shareable links and presentation modes without backend dependencies. It functions as a self-contained static web tool, relying on bundled dependencies for core functionality.
APKDeepLens is a Python-based CLI static analysis tool for Android APK security assessment. It decompiles APKs using bundled JADX, analyzes AndroidManifest.xml for misconfigurations, scans decompiled source code for OWASP Mobile Top 10 vulnerabilities, detects hardcoded secrets and insecure URLs, and generates reports in JSON/HTML/PDF/TXT formats. The architecture is monolithic with modular components for manifest analysis, code scanning, secret extraction, and report generation. Entry point is APKDeepLens.py with argparse CLI interface. External dependencies include JADX (bundled), xhtml2pdf for PDF generation, and python-bidi for PDF rendering.
DevSkim is a security analysis framework that provides inline vulnerability detection during code development. It consists of a core .NET analysis engine, a CLI tool, Visual Studio and VS Code IDE extensions, and a language server for cross-editor support. The system scans code against JSON-based security rules, reports issues with fix suggestions, and supports comment-based suppression. Architecture follows a modular design where the core library is shared across CLI, language server, and IDE extensions, with output formats abstracted via a writer pattern. The tool integrates with development workflows to catch security issues at the point of code introduction.
FluidCalendar is a full-stack Next.js 15 calendar and task-management application intended as an open-source alternative to Motion. In production, it lets users manage tasks and calendar events in a local PostgreSQL-backed store, connect external calendars via Google, Outlook, and CalDAV, and synchronize tasks bidirectionally with Google Tasks, Outlook Tasks, and CalDAV VTODO providers. The application also includes an auto-scheduling engine that finds open time slots and scores them by deadline proximity, energy level, project grouping, and buffer constraints, plus dedicated focus mode, board/list task views, recurring event handling, and rich settings/admin screens. It is not a data-research repository, though its multi-provider synchronization layer has meaningful data-engineering depth.
This repository provides a Docker image for Apache Superset, a data exploration and visualization platform. It is not an application itself but a containerization layer that packages Superset with its dependencies, including helper scripts for initialization and demo data loading. The Dockerfile is well-structured with proper environment variables, healthcheck, non-root user, and multi-architecture build support via CI/CD. The repository includes example configurations for MySQL, PostgreSQL, SQLite, and Celery backends, along with a Makefile for building and pushing images. The codebase is minimal and focused on the Docker build process; there is no application logic beyond the packaging. The dependencies are pinned and up-to-date, and the repository is actively maintained with recent commits and automated workflows.
Zero-Admin is a Go microservices e-commerce backend platform built on the go-zero framework. It provides separate REST API gateways for admin management and frontend storefront operations, with domain-specific gRPC services for product (PMS), order (OMS), member (UMS), marketing (SMS), content (CMS), system administration (SYS), and search (Elasticsearch). The system uses RabbitMQ for async event processing (order lifecycle, product indexing), Redis for caching, and PostgreSQL/MySQL for persistence. It includes scheduled jobs for order timeout cancellation and coupon expiration, and a consumer service for handling message queue events. The architecture follows a consistent layered pattern: HTTP handlers in the API gateways delegate to logic files that call generated gRPC clients, which communicate with RPC servers that execute business logic against the database via a generated ORM (GORM). The codebase is heavily reliant on code generation tools (goctl, gorm.io/gen) for models, queries, and gRPC stubs, resulting in a large number of repetitive CRUD files. While the system is functionally comprehensive, it shows signs of incomplete refactoring (commented-out code, TODO stubs) and uses a non-standard Go dialect that may pose tooling and hiring risks.
This repository implements an Apple Home Key Reader application that enables NFC-based authentication for Apple HomeKit smart locks. The system acts as a bridge between NFC-enabled devices (iPhones/Apple Watches with Home Keys) and HomeKit accessory control, allowing users to unlock locks by tapping their devices on an NFC reader. The architecture follows a modular design with clear separation: main.py coordinates initialization, accessory.py handles HomeKit Accessory Protocol interfaces, service.py implements core NFC authentication logic, homekey.py manages Apple-specific NFC protocols, and repository.py handles persistent state management. The application relies on external dependencies including pyhap for HomeKit, nfcpy for NFC communication, and cryptography for security operations.
Packetdrill is a command-line testing tool for network stack validation, primarily used to test TCP/IP implementation in the Linux kernel. It allows engineers to write deterministic scripts that describe system calls and packet events with microsecond precision, then executes these scripts against a live kernel or a simulated network device (TUN) to verify behavior matches expectations. The tool supports local testing via TUN devices and remote testing over physical NICs using a custom wire protocol. It is developed by Google and licensed under GPLv2. Architecturally, packetdrill is a single C executable built from about 50 source files. It uses flex and bison for script parsing, a state-machine runtime engine (run.c, run_packet.c, run_system_call.c) for event execution, and platform-specific network I/O modules (packet_socket_linux.c, netdev.c, wire_client/server.c). The test suite includes hundreds of script files covering TCP congestion control, fast open, ECN, zerocopy, timestamping, and many other protocol behaviors. The tool also supports optional PSP (Packet Security Protocol) encryption for testing secure tunnels. The codebase demonstrates solid engineering craftsmanship: clearly separated concerns, portable network header definitions that avoid kernel header dependencies, and a well-documented protocol DSL. It is primarily valuable as a reference for kernel networking development and as a reusable testing framework for anyone working on TCP/IP stack implementations. While some parts are tightly coupled (e.g., packet parser to internal packet types), several utility modules (checksum, IP address parsing, hash map, logging) are self-contained and easily reusable in other C projects. The main risk is technical drift due to evolving kernel APIs and custom header definitions that may become outdated.
This is a TypeScript library providing a builder API for typesafe Next.js server actions with Zod validation. It is structured as a monorepo with core package `zsa`, React hooks (`zsa-react`), React Query integration (`zsa-react-query`), and OpenAPI exposure (`zsa-openapi`). The core library supports input validation (JSON, FormData, useActionState), procedures for middleware chaining with context propagation, typed error handling via `ZSAError`, configurable retries and timeouts, and client-side hooks (`useServerAction`, `useActionState`). The OpenAPI module generates REST endpoints and OpenAPI specifications from server actions. The codebase is well-organized with fluent builder patterns, comprehensive test coverage (Jest + Playwright), and a documentation site using Fumadocs. However, it is a personal project currently lacking support for Next.js 15, and all packages are pre-1.0 (0.x), indicating potential instability and limited maintenance commitment.
Word Formatter Pro is a desktop application for formatting Word documents according to Chinese public document standards. It processes .docx, .doc, .wps, .txt, and .md files, outputting standardized .docx files. The application features a cross-platform GUI (Tkinter/tkinterdnd2) with drag-and-drop support, a CLI for batch processing, and a headless Skill for agent integration. Core functionality includes automatic recognition of titles/headings, figure/table captions, attachments, punctuation normalization, blank line handling, and table formatting. Legacy format conversion uses LibreOffice on non-Windows platforms and COM automation on Windows. The architecture separates concerns into GUI, CLI, core logic (WordProcessor), configuration, and numbering modules, with a self-contained Skill directory for reuse.
FastCopy (published as RoboCopyEx, v1.2.1.0) is a Windows desktop utility that replaces Explorer's default copy/move/paste/delete with a robocopy-backed engine. In production it is three cooperating native components: a WinUI 3 (C++/WinRT, Windows App SDK 1.8) application that renders copy progress, a speed graph, pause/resume, duplicate-file conflict resolution and delete confirmations; a COM shell-extension DLL that adds copy/move/paste/delete items to both the new Windows 11 and legacy Explorer context menus; and a global keyboard-hook executable that intercepts Ctrl+V inside Explorer to route pastes through FastCopy. A fastcopy:// URI handler (CommandLineHandler) is the transport by which components pass operations to the main app. The solution is an MSIX package of six projects: FastCopy (UI), FastCopyShellExtension (Explorer COM DLL), FastCopyKeyboardHook (global hook EXE), RobocopyInjection (DLL injected into robocopy.exe to expose per-file progress), UnitTest, and SpeedTest — a TUI benchmark that empirically compares robocopy, xcopy, std::filesystem, IFileOperation and SHFileOperation. The central data flow: RobocopyViewModel builds robocopy arguments; RobocopyProcess launches robocopy.exe suspended inside a JobObject, injects a DLL to force English locale output, then streams the child's stdout through a regex-driven template parser (OutputRegexParseBase) while ProcessIOUpdater samples GetProcessIoCounters/GetSystemTimes to animate the Win2D speed graph, taskbar progress and Windows toasts. Settings are persisted via a WinRT IPropertySet-backed Settings class and MVVM runtime classes declared in IDL. Engineering quality is mixed and should be read from the code rather than the README's speed claims. The repo knowingly ships a crash after the window is closed; RobocopyInjectDll.h and CreateSuspend.h contain null-byte encoding corruption; numerous features are disabled ('Under development!') or commented out; and the app depends on a third-party WinUI3Package (essential:) control library plus dual vcpkg/NuGet dependency chains, making rebuilds fragile outside the author's machine. The DLL-injection and global-hook design is also the likely reason the Store rejected the package, per drama.md. The last commit (2026-09-19) indicates the project is still actively developed. Despite containing a benchmark harness and careful README performance tables, this is an application, not a data/research repository: there are no datasets, notebooks, or pipelines, and the SpeedTest project is an empirically driven engineering tool, not analysis. Its most durable artifacts are the independently extractable OS-interop helpers and parsing templates described below.
wow.export is a desktop application built with NW.js and Vue.js for extracting, previewing, and exporting 3D assets, textures, maps, audio, and database tables from World of Warcraft. It parses proprietary game formats (CASC archives, MPQ, BLP, M2/M3/WMO models, ADT terrain, DBC/DB2 databases) and converts them to standard formats (OBJ, STL, GLTF, PNG, CSV, SQL). The application features a tab-based UI, a custom WebGL2-based 3D renderer with shader support for Blizzard's rendering quirks (fog, combiner modes, animation), a map viewer with terrain and minimap rendering, and a Blender add-on for seamless import. It supports both modern CASC (CDN) and legacy MPQ installations, includes an auto-updater, and has extensive configuration options for export quality and formats. The codebase demonstrates strong reverse-engineering skills and a solid architectural separation between loaders, renderers, exporters, and UI modules. Several components (BufferWrapper, ExportHelper, WDCReader, GL abstractions) are cleanly abstracted and could be reused in other game tool chains. However, the project is tightly coupled to WoW's evolving data formats and external services (CDN hosts, listfile sources), and contains some technical debt in the form of large monolithic files, hardcoded constants, and limited test coverage. Overall, it is a well-maintained, functional tool with a significant amount of craftsmanship in its format parsers and rendering pipeline.
This repository contains a cross-platform mobile application (iOS and Android) that functions as an AI assistant for Ray-Ban Meta smart glasses. The app connects to the glasses via the Meta Wearables DAT SDK to access camera and microphone streams, then provides various AI-powered features including real-time conversations (Live AI), image recognition (Quick Vision), food nutrition analysis (LeanEat), real-time translation, and experimental RTMP streaming. The architecture follows MVVM patterns on both platforms, with SwiftUI/Jetpack Compose for UI, ViewModels for state management, and service layers handling API communications with multiple AI providers (Alibaba Cloud, Google Gemini, OpenRouter). Key features include secure API key storage, Bluetooth audio routing for glasses microphones, and integration with external systems like OpenClaw. The application is actively maintained with recent commits and demonstrates solid engineering practices, though the multi-platform nature and reliance on external AI services introduce some complexity.
GS-SDF is a research prototype from HKU-MARS that fuses LiDAR-augmented 3D Gaussian Splatting with a neural Signed Distance Field (SDF) for photorealistic rendering and high-fidelity surface reconstruction. The system ingests data from multiple sensor modalities (LiDAR, RGB-D, stereo) via a modular data parser hierarchy supporting Replica, FAST-LIVO2, KITTI, COLMAP, Oxford Spires, and other formats. It trains a neural SDF field with eikonal and curvature regularization, then initializes and refines 3D Gaussians guided by the SDF to produce view-dependent color and geometry. The pipeline includes real-time ROS visualization (RVIZ), offline mesh extraction via a custom CUDA marching cubes implementation, and evaluation scripts for image metrics (PSNR, SSIM, LPIPS) and structural metrics (Chamfer distance, F-score). The codebase is pre-release, with many TODOs and commented-out code, but exhibits strong modularity in its data loaders, loss functions, optimizer utilities, and coordinate transformations. While primarily a research codebase, it includes application-like features such as a ROS node with interactive keyboard commands and headless rendering modes.
This repository is the official documentation website for the BNB Chain ecosystem, built with MkDocs and deployed to GitHub Pages. It serves as a comprehensive knowledge base covering multiple blockchains (BNB Smart Chain, opBNB, BNB Greenfield, New L1), developer toolkits (BNB Agent SDK, BNB Agent Studio, MPP SDK), and migration programs (BC Fusion). The site includes custom JavaScript for an AI chatbot (SuperIntern) and dynamic footer menus, as well as custom CSS for branding. While primarily a static documentation site, it incorporates interactive elements and external API integrations. The content is well-organized with extensive cross-references, but the codebase is not a software application in the traditional sense; it is a content-driven site with some client-side scripting.
PearPass Desktop is an Electron/React password manager with a local-first architecture: encrypted vaults are stored on-device and synchronized peer-to-peer through Pear Runtime, with no central cloud account. The renderer is a large React application handling vault/record CRUD (logins, credit cards, identities, notes, Wi-Fi, passphrases, custom fields), folders, favorites, TOTP authenticator codes, import/export from other password managers, and extensive settings. The Electron main process spawns a Bare-sidecar vault worklet, exposes a preload bridge, and coordinates secure native messaging with a browser extension. The repo also includes Flatpak/Snap/AppImage/MSIX packaging, an Appling installer, and a Playwright E2E suite. Security is taken seriously: there is an encrypted session handshake (X25519 ECDH, Ed25519 transcript signatures, secretbox, sequence numbers), a method registry separating public vs secure IPC methods, master-password verification, auto-lock, and platform-specific clipboard cleanup. The codebase has extensive Jest unit coverage and Playwright E2E coverage for every record type. However, much of the actual vault crypto and UI kit logic lives in internal @tetherto packages, making this repository primarily application glue around private dependencies. Maintainability is mixed. The README explicitly states development is paused, and there are signs of drift: mixed JS/TS, duplicated attachment/schema logic across many modal forms, a frozen legacy UI component tree, commented-out E2E tests, a likely bug in pairing-token hash construction, and feature stubs marked UNSUPPORTED. It remains a well-organized and functional password manager, but a significant refactor would be needed to fully modernize it.
This repository implements a Chinese-localized version of the Stanford Generative Agents simulation. It creates a virtual town with 25 AI agents powered by LLMs (primarily via Ollama) that autonomously organize events, form relationships, and exhibit human-like behaviors. The system consists of a simulation engine that runs agent interactions over time, a compression tool to generate replay data, and a Flask-based web frontend for visualizing the simulation. Agents maintain memory, generate plans, reflect on experiences, and interact through LLM-driven conversations and actions. The application supports local deployment with configurable LLMs and includes features like breakpoint resumption and conversation logging.
CoexistAI is a research assistant framework implemented as a FastAPI application that provides a suite of API endpoints for web search, YouTube and Reddit retrieval, geospatial mapping, git repository analysis, text-to-speech/podcast generation, and knowledge base creation from local files or crawled websites. It integrates with an MCP server for agentic workflows and supports pluggable LLMs (Google, OpenAI, Ollama, local) and embedders (Google, HuggingFace, Infinity). The architecture is monolithic with modular utility functions, containerized via Docker with a companion SearxNG instance for privacy-respecting search. The codebase demonstrates a hybrid nature: while primarily an application with explicit API entry points, its core purpose is to support research and data-gathering tasks, making it equally relevant for data research scenarios. Configuration is centralized, and the system includes a web-based admin UI for runtime parameter changes. Active development is evident from recent commits and numerous utility modules, though some global mutable state and fallback-heavy code indicate where the system has evolved rapidly.
RisohEditor is a free, GPL-3-licensed Win32 resource editor for manipulating PE files (EXE, DLL, OCX, CPL, etc.) and resource scripts (.rc, .res). It supports editing all standard Win32 resource types — dialogs, menus, icons, cursors, bitmaps, string tables, version info, accelerators, toolbars, message tables, HTML, manifests, and custom types — as well as visual dialog design (RAD editor), a hex editor (BinEdit), an embedded scripting language (EGA), and integration with external tools like windres, mcpp, UPX, and DFM converter. The architecture is a monolithic desktop application built on a custom Win32 wrapper framework (MZC4) with hundreds of dialogs, property sheets, and preview windows. It runs on Windows XP through 10 and ReactOS, is localized into 17+ languages, and includes a comprehensive constants database for Win32 resource identifiers. Key entry points: wWinMain in RisohEditor.cpp, MMainWnd class for UI orchestration, and the EntrySet resource container. The codebase is large and functionally rich but suffers from high coupling, global state, and limited test coverage; however, several utility classes (MByteStream, BinEdit, MWindowBase, MacroParser) are well-isolated and potentially reusable.