This repository contains the source code for SimpRead (įŽæĻ), a browser extension for Chrome and Firefox that provides an immersive reading mode, focus mode, annotation, and later-reading capabilities. The extension extracts article content from web pages, applies customizable typography and themes, and supports exporting to numerous services including Markdown, PDF, EPUB, Kindle, email, and cloud storage (Dropbox, WebDAV, Notion, Evernote, etc.). It includes a rules-based site adaptation engine (defined in `website_list.json`) to handle hundreds of specific websites, a plugin system for user-installed scripts, and a notice/focus system to manage reading sessions. The architecture follows a typical browser extension pattern: a background script (`background.js`) manages storage, OAuth, context menus, and cross-tab communication; content scripts (`contentscripts.js`) inject reading and focus modes into pages; and multiple options pages (`options/`) provide configuration, custom CSS, site management, and notice center. The UI is built with React 0.14.8 and a custom Material Design UI kit (`mduikit`), with heavy use of jQuery for DOM manipulation. State is managed through a central storage service (`storage.js`) that provides reactive reads/writes and versioned migration. External integrations are implemented as service classes with OAuth flows, and a message-action pattern coordinates between isolated script contexts. The codebase demonstrates a strong feature set but suffers from significant technical debt: very old dependencies (webpack 1, React 0.14), deprecated lifecycle patterns, extensive global DOM manipulation mixed with React, hardcoded CDN links and provider secrets, and comments indicating hacky browser workarounds. The site adaptation rule set is large but fragile, relying on exact CSS selectors and inline JavaScript that break when websites change. Despite these issues, the project provides a wealth of reusable patterns, particularly in its custom UI components, notification system, and storage abstraction.
This repository is the build and packaging meta-repo for Hangover, a project that enables running x86 Windows applications on ARM64 Linux by combining Wine with CPU emulators (FEX, Box64). It contains CI workflows (GitHub Actions) that build Wine with ARM64EC support, compile emulator DLLs, and produce Debian/Ubuntu packages. The actual source code resides in submodules (wine, fex, box64). The repository itself is purely infrastructure: Dockerfiles, debian packaging files, and a complex multi-stage CI pipeline. It is actively maintained with regular releases. There are no reusable software components; the value is in the integration and packaging, not in original code.
GoPhantom is a Go-based Windows loader generator designed for security research. It creates executables that embed and decrypt payloads and decoy files while employing various evasion techniques to avoid detection. The application takes input files (decoy and payload), encrypts them, generates Go source code using templates that incorporate the encrypted data and selected security features, then compiles this code for Windows/amd64. The resulting executable can showcase the decoy file to the user while executing the payload through techniques like process injection, API hashing, direct syscalls, memory protection evasion, and module stomping to make malicious code appear as legitimate DLL code. The project is explicitly archived and no longer actively developed, as stated in the README.
This repository implements an automatic texture atlas generation library for 3D meshes. Its primary function is to take an arbitrary triangle mesh (typically loaded from an OBJ file) and produce a UV-mapped mesh with a compact, packed texture atlas. The algorithm segments the mesh into charts based on geometric and topological criteria, parameterizes each chart using least-squares conformal mapping (LSCM) or orthogonal projection, and packs the charts into a single bitmap using a brute-force or random bin-packing strategy. The library is designed to handle non-manifold meshes, supports colocal vertices, and provides quality metrics such as stretch and conformal distortion. The architecture is modular, with separate libraries for core utilities (nvcore), mathematics (nvmath), mesh data structures (nvmesh), and image handling (nvimage). The public API is a single C-linkage function `atlas_generate` with options for quality, texel density, and packing alignment. The codebase was originally developed for use in the video game 'The Witness' and is released under the MIT license. It includes a test harness that loads an OBJ file and prints atlas results. The repository is functionally complete but shows its age: it predates C++11, uses custom containers instead of STL, and relies on vendored dependencies (tinyobj, stb_image, poshlib) with known limitations. The packing algorithm can be slow for large meshes, and there are numerous TODO comments and dead code paths. Despite this, the underlying algorithms are sound and the half-edge mesh, sparse solver, and rasterization components are well-implemented and could be extracted for use in other 3D projects.
Open-R1 is a research-focused application for reproducing DeepSeek-R1's training and evaluation pipeline. It provides scripts for supervised fine-tuning (SFT) and group relative policy optimization (GRPO), along with tools for synthetic data generation using teacher models, dataset filtering based on pass rates, and evaluation on reasoning and code benchmarks (AIME, MATH, GPQA, LiveCodeBench). The project is a collection of CLI scripts and Python modules rather than a deployed service. It integrates tightly with Hugging Face Hub, Weights & Biases, and external code execution providers (E2B, Morph, Piston) for reward computation. The codebase exhibits good modularity in its reward functions and code execution provider abstractions, but is now deprecated in favor of upstream TRL. The repo is primarily a training/evaluation application, though aspects like dataset filtering and decontamination make it hybrid with data-research characteristics.
DuplexSpyCS is a full-featured Remote Access Trojan (RAT) command-and-control (C2) framework written in C# (.NET WinForms). It consists of a server-side management console and multiple payload variants (winClient48, winClient48DLL, Tipoff, etc.) that provide comprehensive post-exploitation capabilities: file manager, remote desktop, keylogger, webcam/microphone streaming, registry editor, process/task manager, remote shell (including xterm via WebView2), SOCKS5 proxy, and a plugin system for credential theft (Chrome, Edge, Firefox, MobaXterm). Communication uses a custom binary protocol (clsDSP) over TCP, TLS, or HTTP with RSA-AES hybrid encryption. The payloads employ persistence via registry/startup, UAC bypass, process injection (APC, EarlyBird, CreateRemoteThread, etc.), and fileless execution. The codebase is extensive but exhibits significant code duplication across payload projects, many incomplete or stub features, and outdated dependencies (AForge, NAudio, SharpPcap). It is explicitly designed for offensive security research and learning, but carries high risk of misuse.
Estela is an open-source web scraping orchestration platform (analogous to Scrapy Cloud) for deploying, scheduling, and monitoring Scrapy-based spider projects on Kubernetes. It consists of a Django REST API backend with Celery for async task management, a React/TypeScript frontend with Ant Design, and a Kafka-based queue consumer for streaming scraped data into MongoDB. Core workflows include project management, spider deployment (Docker image build via Kaniko), job execution with configurable resource tiers, cron scheduling, data persistence settings, and a metering subsystem for usage tracking. The system relies on external dependencies such as Kubernetes, Kafka, MySQL, MongoDB, Redis, and object storage (MinIO/S3). The frontend provides interactive charts, a tour overlay for onboarding, and notification management. While functional and extensible, the codebase shows signs of age (outdated Django/Celery versions, class-heavy React components, duplicate logic in cron expression handling) and has incomplete test coverage.
Sophia is an embedded transactional key-value/row storage engine written in C, designed for high performance with ACID guarantees, MVCC (Multiversion Concurrency Control), and serializable snapshot isolation. Its architecture is inspired by LSM-trees but uses a unique node/branch/region model with O(1) worst-case set/delete and amortized O(branches) get. The system supports multiple databases, secondary indexes, custom comparators, upsert callbacks, compression (LZ4, Zstd), hot backup, online compaction/checkpointing, write-ahead logging (WAL), and crash recovery with fault injection. The codebase is modular with layers: a portable standard library (allocators, VFS, data structures, iterators, compression filters), a format/schema layer, an index layer, a transaction manager with deadlock detection, a scheduler for background jobs, and a public C API (sp_*). It includes an extensive test suite with unit, functional, crash, multithread, and hermitage isolation tests. The project is no longer actively developed, and the bundled third-party compression libraries are outdated, but the design and abstractions remain of educational and archival value.
This repository is a comprehensive collection of red teaming tactics, techniques, and procedures (TTPs) presented as markdown cheatsheets and guides. It is not a software application or data pipeline; rather, it is a knowledge base containing hundreds of embedded code snippets (bash, PowerShell, Python, Go, Rust, C, etc.) organized by platform (Linux, Windows, macOS, Cloud, ICS, Web). The repo includes a few standalone tools such as an Azure subdomain enumeration Metasploit module, a Flask-based C2 redirector container, a PDF generation script, and a PAM module for credential harvesting. The primary value is as a reference for offensive security operators, not as a runnable application. Architecture is document-based with no API, CLI entry point, or library exports. External dependencies are minimal (mostly system tools).
This is an Android application for network traffic capture and diagnostics, functioning as a mobile proxy similar to Fiddler. The core functionality revolves around intercepting HTTP/HTTPS traffic via a locally running BrowserMobProxy instance, capturing requests/responses in HAR format, and providing tools for modifying traffic (via response injection rules), exporting captures, and performing network diagnostics (ping, DNS, traceroute). The architecture follows standard Android patterns with Activities, Fragments, Services, and Utils classes, but integrates deeply with modified versions of Netty, BrowserMob Proxy, and LittleProxy for MITM capabilities. Key entry points include MainActivity (UI launcher), SysApplication (proxy initialization), MyVpnService (system-wide traffic capture via VPN), and LDNetDiagnoService (diagnostic tasks). The application requires manual installation of a CA certificate for HTTPS interception and stores configuration in SharedPreferences. While functional, the codebase exhibits maintenance challenges including reflection-heavy Android version-specific code, complex SSL/TLS management, static state risks, and dependencies on forked libraries that may lag upstream.
This repository is a curated collection of code implementations, cheat sheets, and study resources for software engineering (SDE) interview preparation. It contains hundreds of independently written C++, Python, and C files covering fundamental data structures (arrays, linked lists, stacks, queues, trees, graphs) and algorithms (sorting, searching, dynamic programming, greedy, backtracking, string algorithms, etc.). The repo also includes problem sheets from popular SDE preparation resources (Striver's SDE Sheet, Love Babbar DSA Sheet), competitive programming patterns, and notes on core subjects like DBMS, OS, and CN. It is primarily a reference/learning resource rather than a cohesive application or data pipeline; the code is not packaged as a library and lacks tests, build systems, or dependency management. Many files are standalone textbook-style implementations. While the breadth is impressive, the depth and consistency of quality vary significantly across contributions, and the repository appears to be in a stale maintenance state with no recent meaningful code updates.
ManifestHub is a Steam Depot Manifest Cache that provides an API for accessing Steam depot manifests. The repository contains documentation and data files (appaccesstokens.json mapping depot IDs to access tokens) but does not include the actual application source code in the visible file tree. The service requires an API key, depot ID, and manifest ID to retrieve manifests via the endpoint https://api.manifesthub1.filegear-sg.me/manifest. Based on the README, it supports latest manifests and workshop manifests, with free API keys valid for 24 hours. The project appears to be actively maintained with recent commits.
This repository implements an MCP (Model Context Protocol) server that provides programmatic access to Xiaohongshu (Little Red Book), a Chinese social media platform. It exposes tools for searching notes, retrieving note content and comments, posting comments, checking cookie validity, and fetching the home feed. The server is built with FastMCP and runs over stdio or TCP, designed for integration into MCP clients like Claude Desktop. Authentication relies on a user cookie, which must be manually supplied. The architecture uses a dual API approach: API v1 leverages direct HTTP requests with `curl-cffi` and JavaScript signing via `execjs`, while API v2 employs Playwright to simulate a real browser session and capture dynamic headers (e.g., `x-s-common`). The signing logic is isolated within heavily obfuscated JavaScript files (`xhsvm.js`, `xhsvm_v2.js`) that implement a custom virtual machine to execute bytecode and compute API parameters. This reverse-engineering effort is the core enabler of the wrapper but introduces significant brittleness. The project is in alpha stage and includes a staged smoke test script for validation. While the basic structure and MCP integration are clean, the extreme obfuscation of the signing code, fragility of cookie-based authentication, and dependency on specific browser profiles make it a high-maintenance system suitable primarily for experimentation or personal use.
This repository is a personal monorepo of Go CLI tools built by nikivdev, primarily revolving around the 'fgo' command (aliased as 'fe'), which provides a fast, interactive command palette for various developer workflows. The toolset includes AI-powered commit message generation via OpenAI, GitHub PR cloning and checkout, port killing, symbolic link management, scratch directory creation, private forking of repos, and integration with macOS-specific tools like osascript and pbpaste. Additional standalone CLIs include 'spec' for converting Markdown specs into Codex execution prompts with optional publishing to unhash.sh, 'ghx' for PR diff retrieval, 'tscp' for Tailscale-based file copy, and 'unite' for unified fuzzy search across multiple CLIs. The repository also contains an experimental Dockerfile layer analyzer library with tests. The codebase is actively maintained but heavily optimized for the author's personal macOS environment, with hardcoded paths and macOS-specific dependencies, making it less portable without modification. The architecture is a flat collection of independent CLI tools sharing common patterns like the go-snap CLI framework and go-fuzzyfinder for interactive selection.
This repository is an ESLint plugin (`@factory/eslint-plugin`) developed by Factory AI. It provides a suite of custom lint rules and shared configurations designed to enforce strict code organization, testing, and logging conventions. The codebase is fully AI-generated and explicitly unmaintained, intended for inspiration rather than direct import. It demonstrates high craftsmanship in AST manipulation (e.g., `jest-mock-require-actual`, `structured-logging` rules with auto-fix) and complex configuration curation (e.g., `frontend.js` config with extensive `no-restricted-syntax` selectors banning specific React/Next.js patterns). The rules enforce a highly opinionated architecture, including specific file naming conventions (`.page.tsx`, `.module.tsx`), mandatory middleware in route handlers, and structured logging over template literals. While the code quality and test coverage are strong, the plugin is technically drifted (ESLint 8.x API, TypeScript 5.x) and relies on outdated dependencies, limiting its direct applicability without significant modernization.
This repository contains an open-source Manufacturing Execution System (MES) built on the Qcadoo framework. It's a Java/Spring-based web application designed for discrete manufacturing industries (machining, food packaging, shoe making, clothing). The system follows a modular plugin architecture where core functionality is provided by the framework and specific manufacturing capabilities are implemented as plugins (e.g., order management, production counting, material flow, genealogy tracking). The application uses Hibernate/JPA for ORM, features a plugin system for extensibility, and is designed to run on Tomcat with PostgreSQL. While the code shows evidence of active maintenance with recent commits, it exhibits technical debt through inconsistent naming patterns, duplicated boilerplate code, and reliance on specific versions of dependencies that may cause compatibility issues with newer versions.
This repository aggregates, validates, and serves Chinese TV live stream URLs (m3u8). It uses a Flask web server to expose a curated list of channels, and a set of Python scripts to discover and test stream sources. The main search script (Tv_search/search_Tv.py) leverages Selenium to scrape the tonkiang.us website for channel links, then downloads short video segments to measure speed and filter viable streams. Additional scripts process Henan TV API data and replace sections of the output with ffmpeg-tested sources. The project is a practical, community-driven IPTV source aggregator with a focus on speed and reliability, but the codebase is a collection of tightly coupled scripts with minimal abstraction, making it more of a functional tool than a reusable library.
This repository is the unified documentation site for the Lottie animation ecosystem, hosted at lottie.airbnb.tech. It is a static website built with Docsify, serving markdown documentation for Lottie's Android, iOS, Web, React Native, Windows, and After Effects integrations. The repo contains no source code for the Lottie libraries themselves; those live in separate repositories (e.g., lottie-android, lottie-ios). The documentation covers installation, usage, API references, supported After Effects features, community showcase, and contribution guidelines. The site is purely informational and does not implement any application logic or data processing.
Cube UI is a Vue.js 2.x-based mobile UI component library providing reusable components for building mobile/web applications. It offers a comprehensive set of touch-optimized UI elements including buttons, forms, pickers, popups, drawers, and layout components. The library follows Vue plugin patterns with installable components and supports both declarative template usage and programmatic invocation via a create-api pattern. It includes internationalization support, form validation, and integrates with better-scroll for advanced scrolling components. The repository contains source code, build outputs, documentation, examples, and unit tests.
This is a large community sample collection for Microsoft Defender for Cloud (MDC, formerly Azure Security Center), organized as a catalog of hundreds of individually deployable artifacts: Azure Policy definitions (deployIfNotExists/audit/deny), Logic App SOAR playbooks reacting to MDC alerts and recommendations, PowerShell remediation and reporting scripts, ARM/Bicep/Terraform IaC, deployable Azure Workbooks with embedded KQL/Azure Resource Graph queries, and structured lab/onboarding modules for MDC features. The most engineering-mature component is the MDC-to-Azure DevOps connector under Workflow automation â a Python 3.12 Azure Durable Functions application with async REST clients (httpx + DefaultAzureCredential + tenacity retry + token caching), pydantic models, XSS-safe HTML triage briefing rendering, deterministic deduplication, idempotent ADO process provisioning, Bicep infrastructure, and a test suite. Everything else ranges from polish to rough: many playbooks and policies are boilerplate-heavy, contain placeholder parameters, hardcoded identifiers, malformed ARM expressions (e.g., doubled `[[` escapes), typos, and references to deprecated APIs/modules (AzureRM, AzureAD, MMA, 2016-2017 Logic App API versions). Architecturally this is not one system but an operational knowledge base: the top-level folders (Policy, Remediation scripts, Workflow automation, Powershell scripts, Pricing & Settings, Workbooks, Secure Score, Labs, Onboarding, Simulations) each form a sub-catalog, with per-folder README deploy buttons. The dominant character is application/infrastructure automation; data-research elements are limited to reusable ARG/KQL snippets, PowerBI template reports, and workbook dashboards that query Azure Monitor metrics and securityresources for cost and posture analytics rather than any research pipeline. The most reusable data-oriented assets are the ARG query snippets (open recommendations, secure score joins, regulatory compliance, vulnerability summaries) and the compose-with-union KQL builder in the connector. The repository receives regular commits and recently added new lab modules (AI workloads, Defender XDR, container runtime anti-malware, code reachability), so it is maintained but unevenly: some directories are current while others remain frozen with legacy branding (ASC, master-branch URLs, old repo paths). An engineer reusing artifacts here should treat every sample as untrusted until validated, parameterized, and tested. The genuinely reusable gems are the connector's client/orchestration/query-builder code and several self-contained onboarding scripts (e.g., AWS EKS access grant); the hundreds of ARM/Policy/Logic App templates are better treated as reference patterns than drop-in deployments.