Ninja is a full-stack web framework for Java, built on Guice dependency injection, FreeMarker templating, and Jackson for JSON/XML serialization. It provides a complete MVC architecture with routing, controllers, filters, sessions, flash scope, i18n, validation, caching, file uploads, WebSockets, email sending, database migrations (via Flyway), and metrics collection. The framework is modular, with separate packages for core, servlet integration, standalone server (Jetty), database, metrics, email, WebSockets, and testing utilities. In production, Ninja applications are deployed either as standalone servers (embedded Jetty) or in servlet containers (Tomcat, Wildfly). The framework handles request routing through a central Routes.java file or annotation-based routing (JaxyRoutes), invokes controller methods with automatic parameter injection and validation, renders templates (FreeMarker) or JSON/XML responses, and manages client-side sessions with signed/encrypted cookies. It includes built-in support for CSRF protection, basic authentication, and secure filters. Key entry points include the Bootstrap class (application startup), NinjaDefault (core request handling), RouterImpl (route matching), ControllerMethodInvoker (parameter injection), and TemplateEngineManager (template rendering). External dependencies include Guice, FreeMarker, Jackson, EhCache/Memcached, Flyway, Apache Commons, and Codahale Metrics. The framework demonstrates strong engineering practices with clean abstractions (filter chain, argument extractors, template engine interface, cache provider), extensive test coverage, and a modular design that allows selective use of features. However, some areas show technical drift with deprecated APIs, aging library versions, and duplicated test code across modules.
WxCleaner is a cross-platform desktop application for detecting and removing duplicate files in WeChat storage directories. It uses a three-stage hashing algorithm (size → partial hash → full hash) to efficiently identify duplicates while minimizing disk I/O. The GUI, built with ttkbootstrap, provides real-time progress visualization, sortable file listings, and safe deletion via system recycle bin. Key features include platform-specific font adaptation, automatic WeChat path detection, and multi-threaded operations to maintain UI responsiveness during scans and cleanup. The architecture separates concerns into reusable modules: scanner.py handles the duplicate detection logic with progress callbacks, platform_utils.py provides cross-platform abstractions for file operations and UI elements, and wx_gui.py manages the Tkinter-based interface. The application supports pausing/resuming deletions, visual distinction between original and duplicate files, and contextual actions like opening file locations. Packaging is handled via PyInstaller with automated GitHub Actions workflows for Windows, macOS, and Linux builds. While the GUI components are application-specific, the core scanning and platform abstraction layers demonstrate strong reusability potential. The codebase shows attention to cross-platform compatibility, user safety (using send2trash instead of permanent deletion), and performance optimization through staged hashing. Dependency management is current, and the project maintains active maintenance with recent commits and release automation.
This repository is an installable AI-agent skill that generates PowerPoint decks by producing 16:9 slide images with OpenAI's gpt-image-2 model and packaging them into .pptx files. The actual pipeline is CLI-driven: a natural-language or Markdown slide plan is converted into structured JSON (scripts/md_to_plan.py), combined with a selected style or cloned template profile (scripts/runtime_profile.py, scripts/template_analyzer.py), rendered through a robust API wrapper (scripts/image_generator.py), and assembled into a deliverable PPTX (scripts/generate_ppt.py). It also supports optional 'editable' mode, where generated slides are reconstructed into native PowerPoint objects via python-pptx, plus versioned slide editing, rollback, and deterministic real-image overlay with vision-based QA. This makes it a hybrid application/data repository: the dominant character is a tool, but a large fraction of the repo is a curated corpus of 265+ style specification files that encode design tokens, layout routing rules, and machine-readable JSON layout manifests.
This is a Visual Studio Code extension providing comprehensive language support for Garry's Mod Lua (GLua). It delivers syntax highlighting, autocompletion, hover documentation, signature help, go-to-definition, find references, color picker, type hints, file previews (VTF/PNG), workspace scanning, global variable optimization, and a bytecode heatmap generator. The extension is built as a single Node.js process using the VS Code API, with a custom Lua parser (gluaparse) for AST analysis and a bundled gluac binary for LuaJIT bytecode manipulation. It downloads wiki data from a remote server and caches it locally. The codebase is well-organized into providers and commands, but is tightly coupled to the VS Code extension model and Garry's Mod-specific data sources, limiting direct reuse outside this context. A Python-based generator script for scraping the Facepunch wiki is also included as a separate tool.
This is a privacy-focused Android application for scanning and generating QR codes and barcodes, developed by the SECUSO research group (Security, Usability, Society) at TU Darmstadt. The app uses the device camera to decode codes, supports image picker scanning, and provides a QR code generator for various content types (URL, text, email, phone, SMS, WiFi, vCard, MeCard, BizCard, geo-location, product, calendar, etc.). It emphasizes minimal permissions (only camera, no internet required for scanning) and includes phishing protection by highlighting domains and requiring user confirmation before opening links. The architecture follows standard Android patterns: Activities with ViewModel + LiveData, Room database for scan history, Repository pattern, and a navigation drawer for main sections (Scanner, Generator, History, Settings, Help, About). The codebase is a mix of Java and Kotlin, uses AndroidX, Material Design, ZXing for barcode decoding, and Glide for image loading. It also integrates a backup service via a git submodule (privacy-friendly-backup-api). The app is part of the Privacy Friendly Apps suite and is licensed under GPLv3.
This repository is the RISC-V GNU Compiler Toolchain build system. It provides the infrastructure to build cross-compilation toolchains targeting RISC-V architectures (RV32/RV64) with various C libraries (newlib, picolibc, glibc, musl, uClibc). The codebase consists of autotools-based configure scripts, Makefile templates, vendored Linux kernel UAPI headers for RISC-V, CI workflows, and test infrastructure including DejaGnu board configurations and regression test allowlists. It is not an end-user application but a build orchestration project that compiles GCC, binutils, and associated libraries from source. The architecture is a classic GNU autotools build system with submodule dependencies. Key entry points are the top-level `configure` script and `Makefile.in`, which drive the build of all toolchain components. The repository also includes scripts for running tests on QEMU and Spike simulators, and CI pipelines for continuous integration and nightly releases.
Dataclass CSV is a Python library that maps CSV rows to dataclass instances, providing type-safe reading and writing of CSV files. It leverages Python's standard `csv` module and dataclasses to automatically convert and validate fields based on type annotations. The library supports common types (int, str, float, bool, datetime, date), custom user-defined types, optional fields with defaults, field mapping for mismatched column names, and decorators for date format and whitespace handling. It includes both a `DataclassReader` (iterable over dataclass instances) and a `DataclassWriter` (writes dataclass lists to CSV). The codebase is small, well-structured, and has no external dependencies beyond the Python standard library. It is primarily a library for application developers who need to integrate CSV data with Python dataclasses in a clean, validated manner.
The GNUstep Base Library is a portable, open-source implementation of Apple's Foundation framework, written in Objective-C. It provides the core runtime infrastructure for the GNUstep desktop environment and any Objective-C application on non-Apple platforms. The library includes fundamental data types (strings, collections, dates, numbers), I/O and networking (streams, sockets, URL loading, HTTP), concurrency (threads, locks, run loops, dispatch integration), serialization (archivers, coders, property lists, JSON, XML), internationalization (locales, calendars, formatters), distributed objects, and system utilities. It also ships several command-line tools (gdomap, gdnc, defaults, plutil, autogsdoc) for service discovery, notification delivery, preferences management, and documentation generation. Architecturally, the library is a monolithic shared library (libgnustep-base) with a layered design: a core runtime layer (NSObject, autorelease pools, method forwarding), a collection and value layer (arrays, dictionaries, sets, numbers, values), a system interaction layer (file manager, process info, user defaults, bundles), and a services layer (networking, XML, JSON, distributed objects). The library uses extensive conditional compilation to support multiple Objective-C runtimes (GNU libobjc, Apple's runtime, NeXT runtime) and operating systems (Linux, Windows, Android, macOS). Key internal components include custom inline containers (GSIArray, GSIMap, GSMinHeap), a platform-agnostic threading abstraction (GSPThread), a type encoding parser (GSTypeEncoding), and a private ivar management scheme (GSInternal) for ABI stability. The library is thoroughly tested with hundreds of test programs covering basic functionality, edge cases, regression fixes for security vulnerabilities (buffer overflows, stack overflows), and cross-platform compatibility. However, the codebase shows signs of age: several APIs are deprecated or stubbed (NSGarbageCollector, NSSerializer), platform-specific workarounds are pervasive, and the build system relies on autoconf and GNUstep makefiles. Despite these drawbacks, the library remains actively maintained and is a crucial component for anyone building Objective-C applications outside Apple's ecosystem.
This repository is a community-maintained Obsidian vault and knowledge base for data engineering, published as a static website at dataengineering.wiki. It contains roughly 200 Markdown notes organized into Concepts, FAQ, Guides, Tools, Templates, Community, and Learning Resources. It is not a traditional software application or data pipeline; its product is the curated educational content plus a small publishing/customization layer that renders it. The hybrid nature is documentation-as-code: the meaningful assets are Markdown knowledge notes, while the only actual code is the site customization and CI/CD glue.
objection is a runtime mobile exploration toolkit that leverages Frida to inject a JavaScript agent into iOS and Android applications, enabling dynamic analysis, security mechanism bypass, and sensitive data extraction without requiring jailbreak or root. The system consists of a Python CLI (built with Click and prompt_toolkit) that connects to a Frida device, injects a TypeScript-compiled agent, and provides an interactive REPL for executing hundreds of commands organized by platform and category. It also includes a Flask-based HTTP API for remote interaction. Key entry points include 'objection explore' (attach to a running app), 'objection start' (launch and attach), and 'objection patchapk'/'patchipa' (inject Frida gadgets into mobile packages). The agent exports RPC methods for platform-specific operations such as hooking, heap exploration, filesystem manipulation, SSL pinning bypass, keychain dumping, and cryptographic monitoring. External dependencies include Frida (dynamic instrumentation), Flask (API), Click (CLI), prompt_toolkit (REPL), and platform-specific tools (apktool, aapt, adb, xcodebuild). The architecture follows a command pattern with state management via singletons, a plugin system for extensibility, and a job system for managing hook lifecycles. While the codebase is well-structured and actively maintained, it relies on fast-moving Frida APIs and mobile OS-specific bypass techniques that may drift with platform updates.
RetroShare is a decentralized, private, and secure peer-to-peer communication toolkit implemented in C++ with a Qt-based desktop GUI. It provides messaging, chat lobbies, forums, channels, file sharing, photo sharing, microblogging (The Wire), VOIP, and RSS feed reading, all over a distributed network using PGP identities and GXS (General Exchange Service) for group data synchronization. The architecture is modular with a core library, a separate GUI application, a headless service, and a plugin system (FeedReader, VOIP). Extensive unit tests exist for serialization, GXS sync, and network simulation. The codebase is actively maintained but shows signs of organic growth, including dead code paths, vendored dependencies, and some deprecated Qt usage.
The Gren compiler is a production-grade toolchain for the Gren programming language, a fork of Elm. It functions as a compiler, build tool, package manager, and REPL, targeting JavaScript and HTML output. The system is architected in two stages: a Haskell backend responsible for the core compilation pipeline (parsing, type inference via Hindley-Milner unification, optimization, and code generation) and a Gren frontend (compiled to JavaScript) that handles the CLI interface, dependency resolution, and orchestration of the backend process via JSON IPC. The codebase demonstrates strong software engineering practices, particularly in its use of monadic error handling (Reporting.Result, Reporting.Task), composable pretty-printing (Reporting.Doc), and efficient data structures (Data.Utf8, Type.UnionFind). The parser is specifically designed for space-sensitive grammars, and the type system includes advanced features like constraint solving, occurs check, and pattern match exhaustiveness verification. While actively maintained, the project carries medium technical drift. It relies on unsafe GHC primitives for performance, maintains a dual-language codebase (Haskell and Gren), and inherits the complexity of forking a rapidly evolving upstream project (Elm). Some modules are notably large, and there are incomplete features marked by TODOs. Despite these risks, the core compiler logic and several of its internal libraries are well-crafted and represent high-quality, reusable components.
Spleeter is a Python library and CLI tool for music source separation, providing pretrained models to decompose audio tracks into stems (e.g., vocals, drums, bass, piano). The codebase is structured around a core Separator class backed by TensorFlow estimation, with abstract audio adapters (default FFMPEG), model providers (GitHub releases), and configuration loading from embedded or file-based JSON. The architecture supports both inference and training, with a well-defined pipeline for waveform loading, STFT computation, U-Net-based separation, and output saving. The library is designed for production use with multiprocessing support and Docker deployment. However, it relies heavily on deprecated TensorFlow 1.x APIs (tf.compat.v1, tf.estimator), indicating technical drift. The code is well-organized with clear separation of concerns, reusable components (audio adapter, model provider, utilities), and comprehensive test coverage.
The QwenLM/Qwen3 repository provides resources for the Qwen3 family of large language models, including model cards, documentation, and usage examples. It serves as an application-focused hub for inference, deployment, training, and evaluation of Qwen3 models. The repository contains extensive multilingual documentation, inference demos (web and CLI), deployment guides for various frameworks (vLLM, SGLang, etc.), training examples (using Axolotl, LLaMA-Factory, etc.), quantization techniques, and evaluation harnesses (notably for ARC-AGI). While the core model weights are hosted externally, this repo enables end-to-end usage through well-organized examples and scripts.
Carbonium is a zero-runtime-dependency DOM manipulation micro-library (~1 kB) that exposes a single `$` function. In the browser, `$` resolves a CSS selector to a NodeList and wraps it in a JavaScript Proxy, so the returned value can be used both as an array of elements and as a single DOM element: property reads return the first match, property writes broadcast to every match, and DOM/array methods are proxied to support fluent chaining. HTML strings starting with `<` are parsed with DOMParser for element creation. The package ships ESM, minified ESM, and IIFE bundles built with Rollup, plus TypeScript declarations. The architecture is intentionally minimal: one source module (`src/carbonium.ts`) with a hand-written Proxy handler. The primary data flow is selector/HTML string -> `querySelectorAll`/`DOMParser` -> NodeList -> Proxy -> per-element property/method dispatch. There are no runtime dependencies; development tooling uses TypeScript, Rollup, ESLint, and Playwright. The tests inject the built IIFE into real Chromium and Firefox pages and cover chaining, filtering, classList, style methods, event listeners, and canvas access. Code inspection reveals a gap between README and behavior: direct property assignment on `.style` (e.g., `$('.indent').style.left = '40px'`) writes to `document.body.style` rather than the matched elements, because the `set` trap falls through to `Reflect.set` on the body's CSSStyleDeclaration. Method-style APIs such as `style.setProperty` and `classList.add` work as advertised because they use the captured `currentListNodelist`. The implementation also uses module-level mutable state for style/classList/relList proxies, which is acceptable for synchronous single-threaded browser code but brittle if a proxy is stored and reused across other `$` calls.
UniOffice is a commercial Go library for reading, writing, and converting Office Open XML (OOXML) documents, including Word (.docx), Excel (.xlsx), and PowerPoint (.pptx) formats. It provides a high-level API for document manipulation, supporting features such as text formatting, tables, images, charts, animations, ActiveX controls, digital ink, and 3D models. The library also includes conversion to PDF via the UniPDF dependency. Architecturally, the library is layered: low-level schema types auto-generated from OOXML schemas handle XML marshalling/unmarshalling and validation; a middle layer of wrapper structs (e.g., Document, Spreadsheet, Presentation) provides a user-friendly interface; and conversion utilities transform documents to PDF. Key entry points include the main module (unioffice.go) for namespace handling and document type detection, common/common.go for core types like DocBase and ContentTypes, and the document/spreadsheet/presentation modules for specific operations. Data flows involve reading a ZIP package, parsing XML into schema types, manipulating via the high-level API, and writing back. The library relies on external dependencies such as unipdf (PDF generation), unichart (chart rendering), unitype (font parsing), and others for encryption and image processing. It requires a license key and uses obfuscated generated code to protect intellectual property. Despite the obfuscation, the library contains several well-designed, reusable components such as a storage abstraction, logger interface, wildcard matching, natural sort, measurement conversions, color parsing, MS-CFB binary format reader/writer, and an Excel number format engine. These components are self-contained and could be extracted for use in other projects.
This repository is a performance benchmarking suite for InfiniBand and RDMA over Converged Ethernet (RoCE) networks. It provides a collection of command-line tools (e.g., ib_send_bw, ib_write_lat, ib_read_bw) that measure bandwidth, latency, and message rate for various RDMA verbs (SEND, WRITE, READ, ATOMIC) across multiple connection types (RC, UC, UD, XRC, DC, SRD, Raw Ethernet). The tools follow a client-server architecture where one instance acts as a server and the other as a client, exchanging parameters and data over RDMA or TCP. The architecture is modular, with clear separation of concerns: parameter parsing (perftest_parameters), resource management (perftest_resources), communication setup (perftest_communication), data validation (host_validation, cuda_kernels), and memory backends (host_memory, cuda_memory, rocm_memory, etc.). All core logic is compiled into a static library (libperftest.a) linked by each benchmark binary. The codebase supports a wide range of hardware accelerators (GPUs, NPUs) and advanced features like data validation with SIMD acceleration, encryption, and flow steering. Key entry points are the benchmark main files (send_bw.c, send_lat.c, etc.) which call into the shared infrastructure. External dependencies include the InfiniBand verbs API (libibv, librdma), and optionally CUDA, ROCm, OpenCL, and other vendor libraries. The build system uses autotools with conditional compilation for optional features. The primary data flow involves a client and server exchanging test parameters via a negotiation protocol, then performing a loop of RDMA operations while measuring throughput and latency. Results are printed to stdout or output as JSON. Data validation can be enabled to verify integrity using SIMD or GPU kernels.
This repository implements the Adaptive Query Optimization (AQO) extension for PostgreSQL, a machine learning-based system that improves query planning by learning from historical query execution statistics. The extension integrates with PostgreSQL's planner and executor via hook mechanisms to override cardinality estimation with predictions from per-query-class k-nearest neighbors regression models. It features a multi-layer architecture: preprocessing (query classification and mode handling), cardinality estimation (ML-based prediction), postprocessing (statistics collection and model updates), and shared memory persistence for query statistics and ML models. Key operational modes include disabled, learn, intelligent, controlled, and forced, controlled via GUCs. The system automatically tunes learning/usage flags based on prediction stability and includes background workers for maintenance. The extension requires patching PostgreSQL source and rebuilding, with tight coupling to internal planner structures (e.g., RelOptInfo, Plan nodes) and executor functions. Deployment involves setting shared_preload_libraries, configuring GUCs like AQO.mode, and managing memory limits for query classes and feature subspaces. It provides SQL interfaces for managing query classes (enable/disable, status checks) and EXPLAIN integration for runtime visibility. The test suite includes pgbench integration, SQL scripts for feature validation, and Perl scripts for pg_stat_statements compatibility. While the core AQO logic is highly specialized to PostgreSQL, two components demonstrate extractable excellence: the hash function for query normalization (ignoring constants/whitespace) and the standalone k-NN regression implementation with linear smoothing. These show non-obvious skill in handling SQL variability and efficient online learning. However, the deep integration with PostgreSQL internals, version-specific patching requirements, and complex state management introduce maintenance challenges and technical debt risks, particularly during PostgreSQL version upgrades.
This repository is a free, open-source web application that generates privacy policies and terms of use for mobile and web apps. It provides a multi-step Vue.js wizard that collects app details (name, contact, platforms, tracking, third-party services, etc.) and outputs customizable legal documents in HTML and Markdown formats. The generated policies cover Simple, No-Tracking, and GDPR variants, with support for CCPA, AI, children's privacy, and data deletion clauses. The application is a static site hosted on Firebase, with all logic running client-side via Vue 3 and Bulma CSS. It includes a theme toggle (light/dark), PWA features (service worker, offline caching), and a reviews page built from GitHub issue comments. The build process uses a custom Go toolchain to compile Less, YAML, and templates, minify assets, and add cache-busting hashes. Two locales (English and German) are supported via JSON translation files. The repository also contains a standalone Go tool for generating the reviews page from GitHub API data, and shell scripts for image optimization. Maintenance appears active based on the last commit date (2026-10-06), but this date is implausibly in the future and may indicate test data contamination; the reviews data JSON also contains fabricated future timestamps. The codebase shows moderate technical drift: the Vue.js global production build may lag behind latest releases, third-party service URLs require manual updates, and the custom Go toolchain is not a standard framework. Overall, the application is functional and well-tested with Playwright E2E tests, but the unusual commit dates and reliance on external services (Flycricket, GitHub API) introduce risk.
ArcadeAI is an active reinforcement-learning research codebase that trains deep RL agents to play Robotron: 2084 and Tempest inside MAME. The actual production loop works as follows: Lua scripts running inside MAME instances read game memory, flatten state into binary packets, and send them over TCP to Python servers. The Python side parses frames, computes rewards, processes states into entity/ray/grid tensors, runs DQN or PPO policies, and returns encoded joystick actions back to the emulator. Training uses Rainbow-style DQN for Tempest and a newer PPO implementation for Robotron, with expert rule bootstrapping, behavioral-cloning losses, prioritized experience replay, n-step returns, guidance-rescue mechanisms, and heavily configurable reward shaping. Both game projects include live Grafana-style web dashboards for metrics, game preview, and system monitoring. Architecturally, the repository is split into MAME-side Lua clients, socket bridges, state processors, model definitions, replay buffers, async inference batchers, and training utilities. This is a hybrid research/application repository: it is not a packaged library or service, but a set of tightly coupled research pipelines with duplicated infrastructure across the Tempest and Robotron directories. The repository also contains original Williams and Atari 6809/6502 assembly sources and ROM staging scripts; these appear to support the RL work by documenting game memory layouts, but they are not part of the active training runtime. The strongest assets are genuinely reusable: a sum-tree based prioritized replay buffer, a generic n-step return buffer, and a configurable reward-shaping module with potential-based movement shaping. These components are well-encapsulated and could be extracted into new RL projects. However, the overall codebase is a personal research dump: there are multiple abandoned engines (_old_engine), hardcoded hostnames and environment-specific paths, 3000+ line Lua/Python scripts, duplicate code across game directories, and tight coupling to MAME memory addresses. It is actively maintained and shows high engineering effort in the core training infrastructure, but reuse outside this repository would require selective extraction rather than direct adoption.