AnExplorer is a native Android file-manager application (package dev.dworks.apps.anexplorer) that exposes a Storage Access Framework-compatible DocumentsProvider layer over many storage backends: external/internal storage, USB OTG, root shell, FTP/FTPS, cloud storage (Google Drive, Dropbox, OneDrive, Box via CloudRail), app management, zip archives, recent files, and a note editor. It is a heavily customized fork of AOSP DocumentsUI: the core browsing state-machine, document stack, roots cache, recents persistence, and loader/cursor stack are AOSP-derived, with substantial product-specific additions for monetization, multiple build flavors, PIN security, settings, and Wear OS/TV support. The marketing site in web/ is a static Firebase-hosted page, not part of the application logic. The architecture is a classic Android monolith: Activities and Fragments drive the UI, Loaders and custom Cursor wrappers feed RecyclerView adapters, and each storage backend is implemented as a DocumentsProvider ContentProvider. Main entry points are DocumentsActivity and StandaloneActivity for browsing, plus the provider authority intents for the Storage Access Framework. External dependencies include AndroidX, Firebase Analytics/AdMob/Crashlytics, CloudRail, libaums for USB, Apache Commons Net for FTP, and an in-app billing library. Quality is mixed. The provider and cursor abstractions are reasonably flexible and a few utility components are genuinely reusable, but the codebase carries heavy technical drift: AGP 3.3 alpha, targetSdk 28, deprecated android.app.Fragment/AsyncTask/PreferenceActivity usage, duplicated flavor-specific classes, hardcoded ad and analytics identifiers, and third-party SDKs that are no longer actively maintained. It remains a functional, feature-complete consumer app rather than a modern engineering showcase.
maltego-trx is the legacy Python SDK for building Maltego transforms (the OSINT/graph investigation platform), now explicitly archived and superseded by the actively maintained maltego-transforms SDK. In production it runs as a Flask HTTP server: the Maltego desktop client POSTs an XML transform request to /run/<transform_name>/, the server parses it into a MaltegoMsg, dispatches to a registered transform class, and serializes the resulting MaltegoTransform response back as XML. Transform classes are auto-discovered from the project's local `transforms` package (class name must match the filename and subclass DiscoverableTransform). The package also ships a CLI (`maltego-trx start`/`init`) that scaffolds new transform projects from a template directory, plus a project-level CLI (`project.py runserver/list/local`) implemented in handler.py.
UKIKU is a feature-rich Android application for streaming and downloading anime episodes, built primarily in Kotlin with some legacy Java. It scrapes content from animeav1.com (and related sites) using Jsoup and custom JavaScript extraction, bypassing Cloudflare protection via a WebView-based mechanism. The app offers a comprehensive anime tracking experience: browsing a directory, searching, viewing details, watching episodes via ExoPlayer (with Chromecast and Android TV support), downloading (including HLS), managing favorites and watch history, queuing episodes, earning achievements, and syncing user data to Firebase Firestore or Dropbox. It also includes a gamified economy system (loli-coins) and extensive ad integration (AdMob, AppLovin). The architecture follows MVVM with Room database, WorkManager, and coroutines, but suffers from significant technical debt: duplicate UI layouts (material vs. non-material), deprecated libraries (Anko, RxJava, old MaterialDialogs), fragile scraping logic, weak encryption, and hardcoded API keys. Despite these issues, the app is functional and has a large user base (203 stars, 39 forks). It is not a data research project; it is a consumer Android application.
This repository is a curated list of email newsletter tools, platforms, and resources. It is not a software application or data pipeline; it is a static reference list maintained by a community. The only code is a Python script to alphabetize the markdown lists and a GitHub Actions workflow to run it automatically on pushes to the README. The repository serves as a directory for newsletter creators to discover tools for advertisements, communities, deliverability, discoverability, inbox management, platforms, referral programs, and sponsorships. It is well-organized and actively maintained, but offers no reusable software components beyond the simple alphabetization utility.
This repository is a collection of sample applications and scripts demonstrating how to embed Power BI reports, dashboards, and tiles into custom applications. It covers two primary embedding scenarios: 'App Owns Data' (service principal or master user authentication) and 'User Owns Data' (delegated user authentication). The samples are implemented in multiple languages and frameworks, including ASP.NET Core, ASP.NET Framework, Python Flask, Node.js Express, Java Spring MVC, and React-TS, providing a consistent pattern across stacks. Additionally, the repo includes credential encryption samples for Power BI on-premises gateway data sources, implementing asymmetric key encryption (RSA-OAEP with AES-256-CBC and HMAC-SHA256), and a set of PowerShell scripts for administrative tasks such as workspace management, deployment pipelines, and dataset refresh. The code is explicitly educational and not production-ready. It focuses on demonstrating the integration flow with the Power BI REST API and Azure AD authentication. While the samples are functional, they suffer from significant duplication across languages, with nearly identical logic reimplemented in each stack. Many dependencies are outdated (e.g., cryptography 3.4.6, Flask 2.1.2, msal 1.9.0, React 16), and the code lacks automated tests. The encryption helpers, however, are well-structured and isolated, making them potentially reusable in other projects that need to encrypt credentials for Power BI gateways. Overall, the repository serves as a practical reference for developers learning Power BI embedding, but it requires careful updating and hardening for production use.
This repository is a proxy subscription aggregator that periodically fetches proxy configurations from multiple public sources (Clash, Hysteria, Xray, etc.), merges them, and outputs unified subscription links in three formats: Clash-compatible YAML, base64-encoded text, and sing-box JSON. The system is designed to run as a GitHub Actions workflow every six hours, automatically committing the updated subscription files back to the repository. It relies on external services (Alvin9999/pac2, yebekhe, Pawdroid) for raw proxy data and uses a GeoLite2 database to tag nodes with their country of origin. The architecture is a simple set of Python scripts (merge.py, meta_merge.py, sing-box.py) that share no common library code. Each script reads URL lists from text files, fetches the remote configurations, parses them according to protocol-specific logic (vless, vmess, tuic, hysteria, shadowsocks, trojan, etc.), and appends the results to a global list. The final output is written to the sub/ directory. The meta_merge.py script additionally integrates the merged proxies into a Clash template (templates/clash_template.yaml) and updates proxy-group lists. Key entry points are the three Python scripts, which are invoked by the GitHub Actions workflow. The primary data flow is: URL lists → HTTP fetch → protocol parsing → merged proxy list → formatted output files. External dependencies include PyYAML, geoip2, and the GeoLite2-City.mmdb database (bundled in the repo). The code is functional but exhibits several software engineering weaknesses: global mutable state, duplicated logic (e.g., get_physical_location defined twice), hardcoded file paths, and no test coverage. It is best suited as a reference for proxy subscription aggregation patterns rather than as a reusable library.
This is the Source SDK 2013, Valve's official modding SDK for Half-Life 2, Half-Life 2: Deathmatch, and Team Fortress 2. It provides the full game engine source code, including client and server DLLs, map compilation tools (vbsp, vrad, vvis), distributed processing (VMPI), and a comprehensive set of game entities, AI behaviors, rendering shaders, and UI frameworks. The codebase is a large C++ monolith with heavy use of preprocessor conditionals to support multiple game mods (HL2, HL2MP, TF2, SDK) and platform targets (Windows, Linux, Xbox 360). It includes a NextBot AI framework with behavior trees, a VGUI2 UI system, a material system with shader fallbacks for legacy DirectX levels, and a replay system. However, the repository is effectively a historical snapshot: many proprietary systems are stubbed out, third-party libraries (protobuf 2.6.1, LZMA) are outdated, and the code shows signs of bitrot with deprecated APIs and dead code paths. It is not actively maintained and would require significant modernization for use in new projects.
CorpBot.py is a production Discord bot implemented as a modular cog-based application on discord.py/py-cord. It provides a broad set of server tools: moderation (kick/ban/mute/lockdown/strikes), XP and role progression, music playback through Lavalink/pomice, games (Cards Against Humanity, Minesweeper, Mad Libs), message automation, web scrapers (Reddit, comics, PC part picker, hardware specs), utility commands (translation, encoding, weather, time), and an AIML-driven chat brain. Main.py bootstraps an AutoShardedBot, dispatches message and event hooks to every loaded cog, and provides an interactive console for reboot/update/shutdown; WatchDog.py supervises the process and restarts it based on exit codes. The architecture is organized around dozens of Cogs/ modules that follow a common setup(bot) pattern, pulling utility cogs such as Settings, Utils, DisplayName, Message, and PickList from the bot. Persistent state is stored as JSON through the Settings cog, which exposes server/user/global stat getters and setters; some branches support MongoDB and Redis. Commands are gated by owner/bot-admin/admin permission helpers, and background task loops are started and stopped via extension load/unload listeners. External dependencies include the Discord API, a Lavalink music server, and many public HTTP APIs, along with bundled AIML corpus files and JSON data files. Despite its breadth, the codebase shows organic growth: copy-pasted permission checks, deprecated discord.py API usage, fragile HTML scrapers, dead code paths, and at least one hardcoded credential are present. The most valuable reusable pieces are small cross-cutting utilities (async HTTP downloader, reaction-based pagination, fuzzy search, humanized time formatting) rather than the feature cogs themselves. This is overwhelmingly an application repo, though it ships a substantial conversational-AI knowledge base that could be treated as a data asset independent of the bot.
This repository provides unofficial binary wheels for Pymol-open-source on Windows, along with a source package to build a launcher executable. The primary distribution mechanism is through GitHub Releases where pre-compiled wheels for various Python versions and architectures are made available. The repository contains a minimal setup.py script that compiles a small C++ launcher (PyMOL.exe) which initializes the Python interpreter and runs the pymol module, serving as an entry point for the PyMOL application. The launcher is built using the Python C API's PyConfig interface, ensuring compatibility with Python 3.7 and later. The setup.py script handles the compilation of the launcher and its installation as a data file when the pymol-launcher package is installed. The repository also includes an icon file (PyMOL.ico) for the launcher executable. While the repository does not contain the source code for PyMOL itself, it facilitates the easy installation and execution of PyMOL on Windows systems by providing the necessary wheels and launcher. The build process relies on numerous external dependencies (such as Boost, VTK-m, and various multimedia libraries) as detailed in the release notes, and requires the Microsoft Visual C++ Redistributable to run. The project is actively maintained with recent commits and releases.
Ruote is a mature Ruby workflow engine (BPM) that orchestrates long-running business processes through a tree of expressions (sequence, concurrence, if, participant, etc.). The engine routes workitems to registered participants, persists process state via pluggable storage backends (in-memory, file system, composite), and supports process definitions in Ruby DSL, XML, JSON, and a custom Radial format. It provides a full API via Ruote::Dashboard for launching, canceling, pausing, and inspecting processes, along with error handling, timers, observers, and cross-process communication via await/listen. The codebase is well-structured with a clear expression lifecycle, participant abstraction, and a service-oriented architecture. However, the project is explicitly deprecated—the README states 'Do not involve ruote in your new project' and directs users to the successor flor. Development ceased around 2013, and the code relies on outdated Ruby idioms and dependencies (e.g., sourcify, parslet 1.4.0), making it unsuitable for modern Ruby projects without significant adaptation.
This repository contains a proof-of-concept CLI tool for recovering text from pixelated screenshots, specifically targeting password recovery. The core algorithm identifies same-color rectangles in the pixelated image, computes their average color (with optional gamma correction), and matches them against a search image containing a De Bruijn sequence of expected characters. Geometric relationships between matched blocks are used to resolve ambiguous matches. The tool is implemented as a single Python script (depix.py) with a supporting library (depixlib) for image loading, rectangle detection, and matching logic. Additional utility scripts generate pixelated images and visualize detected boxes. The code is functional but lacks tests, dependency pinning, and modern packaging; it is a proof-of-concept rather than a production-ready application. The README indicates the project has migrated to Codeberg, suggesting the GitHub repository is no longer actively maintained.
NDlib is a Python library for modeling and simulating diffusion processes on complex networks, with a strong focus on epidemic compartment models and opinion dynamics. It provides a collection of built-in models (SIR, SEIR, voter model, bounded confidence, etc.), a flexible compartment-based composition system for building custom models, and a domain-specific language (NDQL) for defining models declaratively. The library also includes an interactive dashboard server for code-free experimentation, visualization modules (matplotlib and bokeh), and a sensitivity analysis runner via SALib. While the codebase demonstrates solid architectural patterns such as abstract base classes, configuration objects, and block schema registries, it suffers from significant technical drift: it retains Python 2 compatibility shims (six, future), uses outdated dependency versions, and has brittle test infrastructure. The dashboard and parser rely on dynamic code generation that is fragile. Overall, NDlib is a functional research-oriented library with reusable compartment and configuration patterns, but its maintenance has stalled, making it risky for new projects without substantial modernization.
This repository provides a complete firmware solution for building a DIY force feedback (FFB) steering wheel for sim racing, targeting Arduino Leonardo/Micro/ProMicro (ATmega32U4). The firmware implements a custom USB HID joystick with full FFB support (constant, ramp, spring, damper, inertia, friction, periodic effects) and runs a 500 Hz control loop. It supports multiple hardware configurations: optical or magnetic encoders, PWM or DAC motor output, load cell pedals, button matrices, shift registers, and more. The codebase is a heavily modified fork of the BRWheel project, with custom Arduino core modifications to enable FFB HID descriptors. The repository includes precompiled HEX files for dozens of hardware variant combinations, wiring diagrams, and a serial configuration interface. While functionally complete and actively maintained, the code exhibits high technical drift due to reliance on Arduino IDE 1.8.5 and manual core patching, and the monolithic structure with extensive conditional compilation makes maintenance and reuse challenging.
This repository is the open-source CLI client for Amazon Q Developer (formerly CodeWhisperer), now deprecated in favor of the closed-source Kiro CLI. It is a Rust workspace with approximately 2000 files, building two main binaries: `q` (terminal chat assistant) and `qchat` (legacy chat binary). The codebase is dominated by auto-generated AWS SDK client crates (amzn-codewhisperer-client, amzn-codewhisperer-streaming-client, amzn-qdeveloper-streaming-client, amzn-consolas-client, amzn-toolkit-telemetry-client), which are Smithy-generated and checked in. Hand-written code includes the chat CLI interactive loop, an agent framework with MCP (Model Context Protocol) support, a semantic search client using local ONNX models (MiniLM) and BM25 indexing, authentication (OIDC with device grant flow), telemetry, and an OS abstraction layer. The architecture is essentially a monolithic CLI application with multiple supporting libraries. About 90% of the source files are generated code, which means the hand-crafted components are relatively small. The project was previously actively maintained but is now effectively archived; the README states only critical security fixes will be accepted.
This repository is a plugin ecosystem for Koolshare-modified Asuswrt-Merlin router firmware. It provides a software center (softcenter) that manages the installation, update, and removal of various router plugins, including DDNS (ddnspod, phddns, appledns), VPN (shadowvpn), download acceleration (kuainiao), network utilities (dualwan, swap, ssid), and a web-based terminal (shellinabox). The architecture is a collection of shell scripts and ASP web pages, with a central softcenter module that handles app store functionality, version checking, and offline installation. Key entry points include softcenter's install.sh, ks_app_install.sh, and Main_Soft_center.asp. Data flows involve downloading plugins as tar.gz archives from remote servers (koolshare.cn, GitHub raw), installing via scripts, and storing configuration in a dbus key-value store. External dependencies include precompiled binaries (curl, wget, perp, speedtest, shadowvpn, shellinaboxd) and remote endpoints for version checks and push messages. The codebase is heavily duplicated, with many identical backup.sh and install/uninstall scripts across modules, and relies on opaque UPX-packed binaries. Maintenance risks include hardcoded endpoints, outdated toolchains, and lack of tests or CI/CD.
This repository contains a Go application designed to run as a service on the reMarkable tablet. It automatically downloads images from various sources (news sites, comics, etc.) and sets them as the device's suspend screen. The application waits for WiFi connectivity, respects a configurable cooldown period to avoid excessive requests, processes images by resizing and centering them to the screen, and optionally overlays text extracted from the source HTML or provided via command line. The architecture is a simple single-threaded service that uses a loop to wait for network events (via dbus) and then fetches and processes an image. Key components include HTTP clients with error handling, XPath-based data extraction from HTML and JSON, image resizing and centering, and text rendering using TrueType fonts. While the application is tailored to the reMarkable's screen size and specific use case, it contains reusable utilities for font loading, text rendering on images, and URL manipulation with XPath extraction. However, some utilities are coupled to global state (such as HTTP headers and log level) which limits their reusability without modification.
kyt is a deprecated monorepo CLI toolkit from The New York Times for scaffolding and developing JavaScript web applications. It encapsulates build tooling (Webpack 4, Babel 7), linting (ESLint 7), testing (Jest 27), and provides starter templates for React apps with client-only, server-only, or universal (isomorphic) rendering. The core package provides three primary commands: `kyt dev` (hot-reloading dev server), `kyt build` (production builds), and `kyt setup` (project scaffolding). Architecture: monorepo with Lerna + Yarn Workspaces; the CLI entry is `packages/kyt-core/src/index.js`; configuration is centralized in `kyt.config.js`, and runtime support (dynamic imports, SSR resolution) is provided by `packages/kyt-runtime`. The tool is no longer maintained and uses dependencies that are significantly behind modern versions (Webpack 4, React 17, Jest 27, ESLint 7). Its value lies in its clean composition of presets, configs, and custom ESLint rules that can be extracted and reused independently.
This repository is a comprehensive, cross-implementation benchmark suite for R7RS Scheme. It provides a standardized harness that compiles and runs approximately 50 benchmarks (covering numerical, symbolic, I/O, GC, and meta-circular workloads) across more than 30 Scheme implementations, capturing execution times and correctness results. The suite exposes portability gaps, performance differences, and implementation bugs through its per-implementation prelude/postlude system, which adapts the common benchmark code to each Scheme's dialect. Results are output as CSV files and aggregated into summary tables and HTML charts (via graph-gmean.scm and graph.scm). While the benchmarks are well-structured and the harness is robust, many implementations are broken or incomplete, preludes are fragile workarounds, and the codebase shows age-related drift (e.g., deprecated APIs, hardcoded paths, and inputs too small for modern hardware).
This is the official Scratch 3.0 graphical user interface (scratch-gui), a React/Redux single-page application that provides the complete web-based editor for creating, editing, and running Scratch projects. It integrates tightly with the Scratch ecosystem (scratch-vm, scratch-blocks, scratch-render, scratch-storage, etc.) to deliver block-based programming, sprite/costume/sound management, stage rendering, hardware extensions, cloud variables, tutorials, and project save/load. The architecture is heavily modular with many Higher-Order Components (HOCs) and relies on a centralized Redux store. While the codebase is large and well-structured for its domain, it exhibits significant technical drift due to outdated dependencies (React 16, Redux 3, Jest 21) and reliance on deprecated lifecycle methods. The repository is being archived and migrated to the scratch-editor mono-repo, as announced in the README.
NSLogger is a remote logging framework for Apple (iOS, macOS, tvOS) and Android platforms. It consists of client libraries (C/Objective-C Swift wrapper for Apple, Java for Android) that send structured log messages (text, binary data, images) over TCP to a desktop viewer application. The desktop viewer (macOS app) provides real-time log viewing with filtering, color coding, search, marks, export, and preference management. An iPad viewer application also exists for on-device log viewing with Core Data persistence and Bluetooth support. The codebase includes multiple Xcode projects for different targets, test apps, and vendored third-party libraries (BWToolkit, HockeySDK-Mac, SSSelectableToolbar). While functional and well-known (4.9k stars), the project shows significant age: manual memory management (non-ARC), duplicated viewer logic across Desktop and iPad, incomplete features (JSON message format stubbed), outdated dependencies, and deprecated API usage. It remains a valuable reference for implementing a custom binary logging protocol and network transport layer, but would require modernization for current platform versions.