This is an Android application that aggregates software outsourcing project information from multiple platforms. It uses a modern Android architecture with MVP pattern, ViewPager for tab navigation, and RecyclerView for displaying project lists. Key features include browsing projects by category, searching for specific projects, viewing project details in a WebView, and sharing projects via social media. The app implements caching to reduce network calls and uses RxJava for asynchronous operations.
RepLDM is a research codebase accompanying a NeurIPS 2025 paper that introduces a training-free method for generating high-resolution images (up to 8K) using pretrained latent diffusion models (SDXL). The core innovation is an Attention Guidance module that enhances detail and color richness by applying a lightweight self-attention transformation to latent representations during denoising. The code provides custom diffusers pipelines (RepLDMSDXLPipeline, RepLDMSDXLControlNetPipeline, FreeScaleSDXLPipeline) that implement a progressive upsampling strategy: initial denoising at base resolution, then iterative VAE encode/decode with additional denoising steps to increase resolution. It supports text-to-image generation and ControlNet-conditioned generation. The repository includes Jupyter notebooks for interactive use and a batch inference script. While primarily a research artifact, the Attention Guidance module is a clean, self-contained component that could be reused in other diffusion pipelines. The code is tightly coupled to specific versions of diffusers and PyTorch, and some internal APIs are used, indicating potential drift with newer library versions.
Travis API is the backend REST API for the Travis CI continuous integration platform. It provides multiple API versions (v0/v1/v2/v3) that expose resources such as builds, jobs, repositories, users, organizations, cron schedules, caches, logs, environment variables, SSL keys, and billing/subscription data. The application is built on Ruby with Sinatra for HTTP routing and ActiveRecord for PostgreSQL persistence. It uses Redis for caching, feature flags, and background job queues (Sidekiq). External integrations include GitHub OAuth, a billing service, a remote VCS service (GitHub/GitLab/Bitbucket/Assembla), a logs API, artifact manager, scanner service, and cloud object storage (S3/GCS). The codebase follows a service-oriented architecture for the V3 API, with clear separation into services, queries, models, renderers, and permission classes. Legacy V1/V2 endpoints coexist, increasing maintenance surface. Authentication supports user tokens, application tokens, and log tokens, with fine-grained permissions checked against an external authorizer or local models. The system also handles enterprise deployments with custom licensing and user suspension. Notable engineering patterns include a generic renderer framework with representation modes (minimal/standard), a pagination system with Redis count caching, an encrypted column implementation, a config obfuscator for secure variables, and a feature flag system using Redis.
This repository is a Visual Studio Code extension for developing, debugging, and simulating Apache Cordova and Ionic mobile applications. It provides a comprehensive debug adapter that supports launching and attaching to Android, iOS, browser, and simulated targets. The extension integrates with the Chrome DevTools Protocol (CDP) via a custom proxy to enable sourcemap rewriting and cross-platform debugging, and it offers IntelliSense for Cordova plugin APIs and Ionic framework components. It also includes commands for building, running, preparing, and cleaning Cordova/Ionic projects, as well as telemetry and localization support across 14 languages. The architecture is modular: the core debug session (`CordovaDebugSession`) delegates to platform-specific implementations (`AndroidPlatform`, `IosPlatform`, `BrowserPlatform`) that inherit from abstract base classes (`AbstractPlatform`, `AbstractMobilePlatform`). A CDP proxy layer (`CordovaCDPProxy`) intercepts and transforms messages between the debugger and the target runtime, with specialized message handlers for Chrome and Safari runtimes. Target management is handled by `MobileTargetManager` subclasses (`AndroidTargetManager`, `IOSTargetManager`) that enumerate devices and emulators. The extension also includes a plugin simulator (`PluginSimulator`) that serves the app via `cordova-simulate` and a Socket.IO connection. Key entry points include the extension activation (`src/extension/cordova-extension.ts`), the debug configuration provider (`src/extension/debugConfigurationProvider.ts`), and the debug session class (`src/debugger/cordovaDebugSession.ts`). External dependencies include the Cordova CLI, Ionic CLI, Android SDK, iOS toolchain (Xcode, ios-webkit-debug-proxy), and npm packages like `cordova-simulate`, `socket.io-client`, and `vscode-js-debug-browsers`. The codebase is written in TypeScript and uses Gulp and Webpack for building. While the extension is functionally complete and well-structured, it shows signs of technical drift: many dependencies are outdated (e.g., `applicationinsights` 0.15.6, `socket.io-client` 2.4.0), the Cordova ecosystem has declined in favor of Capacitor, and the large i18n file set (200+ files) adds maintenance overhead. The code contains some legacy patterns (e.g., `eval` for custom require, extensive use of `any` types) and hardcoded timeouts. Despite this, the core abstractions for platform handling and CDP message processing are well-designed and potentially reusable.
This repository provides a functional system for motion retargeting from human video to robot models. It detects arm and hand poses from monocular video using MediaPipe, fuses the detections, applies multi-stage coordinate transformations (world β first-person β URDF standard), and retargets the motion to robot URDF models using numerical optimization. The system includes visualization tools for debugging coordinate transformations and verifying retargeting results. The architecture is modular with separate components for detection (`src/whobody_dect/`), retargeting (`src/dex_retargeting/`), and example workflows (`example/`). Key entry points include `example/vector_retargeting/retarget_from_wholebody_video.py` for the main retargeting pipeline and `src/whobody_dect/simple_visualize.py` for coordinate system validation.
This is the umbrella monorepo for Evo CRM Community, an open-source AI-powered customer support platform. The repository itself does not contain application source code; it orchestrates seven independent microservices (auth, CRM, frontend, AI processor, core service, bot runtime, and event flow) via Git submodules and Docker Compose/Swarm configurations. The primary function of this repo is to provide a single entry point for cloning, building, seeding, and deploying the full stack. It includes a nginx API gateway for path-based routing to backend services, CI/CD workflows for building and publishing Docker images, migration version collision guards, and extensive release documentation. The actual business logic, AI agent execution, conversation management, and user interface reside in the submodules.
This repository implements a full-stack AI-powered food recommendation application called 'δ»ε€©εδ»δΉ' (What to eat today). The system combines a Next.js frontend with a Python Flask backend that uses a GraphRAG (Retrieval-Augmented Generation) architecture leveraging Neo4j for graph-based recipe relationships and Milvus for vector similarity search. Users interact via a chat interface to receive personalized recipe recommendations with step-by-step cooking instructions. The application includes a comprehensive recipe knowledge base in markdown format, Docker-based deployment orchestration, and a modular RAG pipeline with intelligent query routing and session management.
This is an educational repository of Python scripts, mini-projects, and markdown guides for building LLM-based AI agents applied to cybersecurity. The code is organized into five progressive parts: foundational LLM/embeddings usage, prompt templates, prompt chaining, RAG over security data, and agentic workflows. It demonstrates multiple agent frameworks (LangChain, LangGraph, CrewAI, DeepAgents) and MCP server integrations for tools like nmap and Shodan. The dominant character is application/tutorial code rather than data research, although it bundles small datasets (CVE embeddings, sample RAG corpora) and commits Chroma vector stores for offline exercises. The repo is not a single deployable service; it is a collection of entry-point scripts and small frameworks. Architecture is a set of standalone examples with shared patterns: state graphs for orchestration, YAML-configured crews, MCP adapters, and RAG ingestion/query pipelines. Most scripts require OpenAI-compatible API keys and/or local tools such as nmap/Ollama. Simulated data and placeholder responses in some examples make it a learning environment rather than production security tooling. Maintenance is current but drift is moderate: some examples use deprecated langchain vectorstore imports, documentation is duplicated across subdirectories, several referenced files are missing, and hardcoded model strings like gpt-5.4-mini appear dated or fictional. There is no root-level automated test suite; only the Shodan MCP subproject contains tests. The strongest reusable patterns are the MCP server wrapping, LangGraph conditional-state orchestration, CrewAI declarative crew configuration, and the hierarchical SOC agent supervisor.
This repository implements a local AI assistant for Windows with a focus on privacy and offline operation. The application features a modern Qt-based GUI with multiple tabs for chat, planning, briefing, home automation, and web search. It includes a voice pipeline with wake word detection ('jarvis'), speech-to-text, intent classification via a fine-tuned FunctionGemma model, local LLM inference through Ollama, and text-to-speech using Piper TTS. Core functionalities encompass smart home control (TP-Link Kasa), calendar/task management, weather/news aggregation, and system monitoring. The architecture is modular, separating concerns into core services (LLM, router, function execution, voice assistant) and GUI components, with communication via Qt signals and slots. Data is stored locally in SQLite databases. The project demonstrates thoughtful engineering in areas like reactive settings management, model persistence for VRAM optimization, and reusable UI components, though it maintains some Windows-specific dependencies and tight coupling in certain areas.
Craftium is a voxel-based game engine (Luanti/Minetest fork) extended with reinforcement learning capabilities. The core system provides a moddable 3D world with block-based gameplay, Lua scripting API, client-server architecture, and procedural map generation. The craftium add-on supplies Python bindings, Gymnasium environment interfaces, and RL training scripts to enable machine learning research within the game world. The system supports both traditional gameplay and AI experimentation through environment-specific mods that define reward functions, observations, and termination conditions for agents.
UniTEX is a research-focused repository implementing a two-stage framework for high-fidelity 3D texture generation from arbitrary 3D shapes. Stage 1 uses LoRA-adapted Diffusion Transformers for multi-view texture synthesis, while Stage 2 employs a transformer-based Large Texturing Model (LTM) to predict Texture Functions in unified 3D space, bypassing UV mapping limitations. The repository integrates super-resolution (TSD_SR) for detail enhancement and provides tools for mesh processing, rendering, and texture reprojection. It includes training scripts, model architectures, and utility libraries, indicating its primary purpose is to support experimentation and reproduction of the CVPR 2026 paper's methodology rather than serving as a standalone end-user application.
EDA (Edalitics) is a full-stack, self-hosted business intelligence and dashboarding platform. It is an application rather than a data-research repository, though its core value is data exploration: users connect multiple database systems, generate data models, build interactive dashboards with D3/Leaflet/PrimeNG widgets, define KPIs and alerts, schedule PDF/email reports, and query data through either a no-code visual editor or raw SQL. The backend is an Express + TypeScript REST API backed by MongoDB for metadata, with a connection abstraction layer covering PostgreSQL, MySQL, Oracle, SQL Server, BigQuery, Snowflake, ClickHouse, Vertica, DuckDB, MongoDB, and JSON web services. The frontend is an Angular 17+ standalone-component SPA with gridster-based dashboard panels, a large D3 chart family, cross-tables, maps, and an AI assistant that uses OpenAI, Anthropic, Bedrock, and Qwen providers for natural-language querying, chart suggestions, and automated dashboard generation. Datasource plugins for Google Analytics 4, Odoo, and Holded download data into DuckDB-backed models, and forecasting is available through ARIMA and TensorFlow.js services.
PAML is a suite of command-line C programs for phylogenetic analysis by maximum likelihood, the de facto standard in molecular evolution for estimating substitution parameters, detecting positive selection (codeml NSsites, branch-site, and clade models), computing dN/dS distances (yn00), simulating sequences (evolver), and estimating divergence times with fossil calibrations (mcmctree). Programs are driven by control files using key = value options, consume sequence alignments and Newick trees, and write detailed text outputs (rst, mlc, mcmc.txt, rates). The primary entry points are standalone executables: codeml, baseml, mcmctree, evolver, yn00, pamp, chi2, and ds. This is research software serving empirical evolutionary biology, not a data pipeline or library. Architecturally, the codebase is monolithic legacy C: a central shared header (src/paml.h) plus large shared implementation files (src/tools.c, src/treesub.c, src/treespace.c) are compiled into each program via #define program macros and direct #include of .c files, with heavy #ifdef conditional compilation. The numerical core is sophisticated and battle-tested β eigen-decomposition of rate matrices, matrix exponentials, Newton/BFGS/Levenberg-Marquardt optimizers, discrete-gamma heterogeneity, Bactrian MCMC proposal kernels, and ESS/HPD diagnostics β but is embedded in global state, fixed-size arrays (requiring recompilation for large datasets), hardcoded limits, and extensive #if 0 dead code. The changelog (doc/pamlHistory.txt) candidly documents known regressions and broken features across its 30-year history, a genuine risk for trust-critical reuse. The repository is actively maintained (version 4.10.10, last commit 2026-01-29) with rigorous versioned releases and an exceptionally detailed changelog. Technical drift is medium: the code style is decades-old C with acknowledged weaknesses (unsafe allocations, platform-dependent system() calls, interactive prompts), but the science remains current and the package is still the reference implementation against which newer phylogenetic methods are validated. The most reusable assets are the self-contained numerical routines in tools.c, the tree parsing and site-pattern compression in treesub.c, and the standalone distribution functions in chi2.c; extracting them into a new project is feasible, whereas the monolithic driver programs are too coupled to be worth reusing directly.
This repository implements SPECTRA (Supervised discovery of interpretable gene programs from single-cell data), a PyTorch-based library for analyzing single-cell RNA sequencing data. The core functionality involves fitting a model that combines gene expression data with prior knowledge from gene sets to discover biologically interpretable factors. The system takes an AnnData object containing single-cell expression data, cell type annotations, and a gene set dictionary, then learns factors representing gene programs associated with cellular processes. Key features include cell-type specific factor modeling, GPU acceleration options, and multiple optimization approaches (standard gradient descent and EM variants). The codebase demonstrates good software engineering practices with separable components for utility functions, initialization strategies, and eigenvalue-based factor estimation.
Botdarr is a Java-based chat bot application that integrates with Radarr, Sonarr, and Lidarr media management services, allowing users to search, add, and monitor movies, TV shows, and music via chat platforms (Discord, Slack, Telegram, Matrix). The system uses a monolithic architecture with modular packages: API clients for each media service, command processing, chat platform adapters, and a SQLite database for persistence (e.g., user request limits, callback data). The main entry point is `BotdarrApplication`, which initializes the configured chat client and starts listening for commands. Data flows: user messages are received by the chat client, parsed by `CommandProcessor`, which executes commands that call the media service APIs (via `RadarrApi`, `SonarrApi`, `LidarrApi`), and responses are formatted by platform-specific `ChatClientResponseBuilder` implementations before being sent back. External dependencies include Apache HttpClient, Jackson, JDA (Discord), Slack SDK, Telegram Bot API, Matrix client-server API, and Flyway for database migrations. The codebase demonstrates solid engineering with strategy patterns for lookup/add/downloads, a command pattern for user interactions, and a clean abstraction for chat client response formatting. However, it suffers from technical drift due to reliance on Java 8, outdated libraries (JMockit 1.40, Jackson 2.13.4.1), and manual versioning. The Matrix client support appears incomplete, and response formatting logic is duplicated across platforms, increasing maintenance burden.
MRH-G2Ray is a containerized application that sets up a VLESS proxy server (Xray) on GitHub Codespaces, providing a free, ephemeral proxy service. The system automatically generates a unique UUID per Codespace, configures Xray with VLESS over XHTTP, and exposes an admin web panel (port 8080) with HTTP Basic Auth for easy retrieval of the VLESS connection link. The architecture is a single Docker container running both Xray and a Python-based admin server, orchestrated via devcontainer configuration. It is designed for users in restricted regions to bypass internet censorship using GitHub's free cloud infrastructure. The codebase is modular with separate startup scripts, but tightly coupled to the specific Xray configuration and Codespaces environment.
openstartracker is an application for autonomous spacecraft attitude determination from star images. It runs as a long-lived localhost TCP daemon (startracker.py) that accepts commands via socket or stdin, processes images with OpenCV, and returns matched star vectors. The core matching engine is a custom C++ header library (BEAST) wrapped with SWIG, using a Hipparcos-derived constellation database, Morton-coded spatial hashing, an in-place kd-tree, and Bayesian posterior scoring for lost-in-space identification. It also tracks non-star objects across frames and can extrapolate attitude between image times.
This repository is a full-stack hardware and firmware project that enables a stock Atari 2600 console to play full-length color movies with audio from a custom cartridge containing a microSD card. The system consists of three major subsystems: (1) firmware for a Microchip dsPIC33CK64MC105 digital signal controller that reads movie data from FAT32-formatted SD cards and emulates the Atari 2600 cartridge bus interface in real time, (2) a 6502 assembly display kernel that generates the video signal using the TIA chip's playfield and color registers, and (3) a PC-based encoder implemented as a TouchDesigner C++ plugin (ColorizeTOP) that converts standard video files into the constrained .mvc format (80x192 resolution, 7-bit color, 4-bit audio). The firmware includes a bootloader with a custom update protocol, a Petit FatFs port for file access, and an interrupt-driven Atari bus emulator using computed-goto dispatch. The encoder performs cell-based quantization, kd-tree nearest-color search, and configurable dithering (Floyd-Steinberg, Atkinson, JIN) to map video frames to the Atari 2600's limited palette. The project also includes Eagle PCB designs for three cartridge board variants, assembly utilities, and example .mvc files. The architecture is well-modularized with clear separation between bootloader, main firmware, display kernel, and encoding tools, though some code duplication exists (e.g., flash driver copied across projects).
This repository is a C# port of the Three.js 3D library, providing a comprehensive 3D graphics framework for .NET applications. It implements a scene graph architecture with Object3D hierarchy, supporting geometries, materials, cameras, lights, and various loading mechanisms for 3D models and textures. The library offers multiple rendering backends (OpenTK/OpenGL and Silk.NET) and includes extensive example applications demonstrating features like physically-based rendering, post-processing effects, animation systems, and camera controls. The codebase shows good separation of concerns in core mathematical utilities and event systems, though suffers from some duplication between rendering backends and inconsistent patterns in examples.
AgentHub (also known as Maestro) is an Electron desktop application that orchestrates a virtual software development team of 46 AI agents powered by Claude Code CLI. The system enforces a 'Harness Engineering' methodology: Skills (standardized slash commands), Hooks (pre/post tool interceptors), Gates (quality checkpoints G0βG6), and FileWatchers (auto-sync markdown files to database). The GUI is intentionally limited to monitoring and three core operationsβmost workflow is driven by slash commands within Claude Code sessions. Architecture follows a three-layer pattern: Vue 3 + TypeScript renderer communicates via Electron IPC (contextBridge) to a main process with ~16 singleton services (session-manager, task-manager, gate-keeper, hook-manager, etc.). Persistence uses sql.js (SQLite in-memory) with a debounced disk save and 13 migrations. The source of truth is markdown files in `.knowledge/` and `.tasks/` directories, which are watched by chokidar and synced to the database. The app supports bilingual UI (zh-TW/en) and runs on Windows, macOS, and Linux. Key features include: sprint-based project management with task dependency tracking, interactive terminal sessions (xterm.js + node-pty), cost tracking per session, Git integration, a gate pipeline with review workflows, and a skill/hook management system with hash-based idempotent deployment. The codebase is well-structured with reusable components and services, though it shows some technical drift (alpha dependencies, brand name mismatch, Windows-specific paths) and high complexity from the extensive agent definitions and knowledge base.