This repository implements a multi-agent company research system that generates structured, source-backed briefings. The backend is a FastAPI application that orchestrates a LangGraph workflow: specialized researcher nodes (company, industry, financial, news) use Tavily search and LLM-generated queries to collect data, a curator filters by relevance scores, an enricher fetches raw content, a briefing node synthesizes category summaries, and an editor compiles the final report. The frontend is a React + Vite UI that submits research requests, streams progress via Server-Sent Events (SSE), and displays the completed report with PDF export. The system supports flexible LLM configuration via OpenRouter (recommended) or direct OpenAI/Gemini keys, and optionally persists jobs in MongoDB. The architecture is modular, with clear separation between research, curation, enrichment, briefing, and editing phases, all connected through a state graph. The code demonstrates solid use of async patterns, LangGraph for workflow orchestration, and a clean React frontend with real-time updates.
Podkop is an OpenWrt LuCI application that provides a comprehensive web interface and backend service for managing the sing-box proxy engine on routers. The architecture is a monolith split between a TypeScript frontend compiled to LuCI-compatible JavaScript and a shell-based backend orchestrated by the `/usr/bin/podkop` CLI script. The frontend employs a clean reactive store pattern and modular validators, while the backend handles sing-box configuration generation, nftables TPROXY routing, FakeIP DNS management, and community list updates. The system allows users to configure complex proxy routing rules (VLESS, Trojan, Shadowsocks, etc.), monitor real-time traffic and connections via the Clash API WebSocket, and run extensive diagnostics on DNS, sing-box, nftables, and FakeIP functionality. Data flows from UCI configuration through shell scripts to sing-box JSON configs, and from external community lists (GitHub) into local sing-box rulesets. The project is actively maintained with recent commits, CI pipelines, and responsive issue triage. However, it carries medium technical drift due to tight coupling to the LuCI framework, reliance on external services (`fakeip.podkop.fyi`, `ip.podkop.fyi`), a monolithic shell backend with global state and an empty migration function, and heuristic security masking that may not cover all edge cases. The most reusable components are the frontend validators (`fe-app-podkop/src/validators/`), which provide robust, well-tested parsing for various proxy URLs, and the generic `StoreService` pattern. The shell helper library (`podkop/files/usr/lib/helpers.sh`) also contains reusable URL parsing and validation functions. These components demonstrate high craftsmanship and can be extracted for use in other networking or proxy management projects.
This repository is a PowerShell-based desktop GUI application for managing Microsoft Intune (Endpoint Manager) configurations. It uses the Microsoft Graph API and Azure Management APIs to perform operations such as exporting, importing, comparing, and bulk copying Intune objects (policies, profiles, apps). The application features a WPF user interface defined in XAML, MSAL-based authentication with proxy support, and a modular extension system that allows adding new functionality (e.g., documentation generation in HTML, Markdown, JSON, Word, CSV). It also includes tools for ADMX policy ingestion, Intune app upload (MSI, MSIX, iOS, Android, Win32), and encryption key extraction from .intunewin files. The codebase is primarily PowerShell with some C# helper classes for MSAL integration.
Llama Tutor is an open-source AI personal tutor built as a Next.js application. It allows users to enter a topic and select an education level (elementary to graduate), then uses Exa search to fetch relevant web content and Together AI (Qwen2.5-7B-Instruct-Turbo) to generate a personalized lesson in streaming markdown. The application features conversational follow-ups, source display, and rate limiting via Upstash Redis. It integrates Helicone for observability and Plausible for analytics. The codebase is a monolith with App Router, client-side state, and edge-deployed API routes. The architecture is straightforward: the main page orchestrates chat and source retrieval, relying on a custom streaming utility for Together AI responses. While the components are functional and well-structured for a demo, only the streaming utility stands out as a potentially reusable pattern for other AI-powered applications.
HotGo is a full-stack rapid-development admin platform, not a data-research project. The Go backend (GoFrame v2, go.mod declaring Go 1.24) ships as a single monolith binary with modular entry points: an admin HTTP API, a public member/payment API, home page rendering, WebSocket push, a custom TCP server/client, queue consumers, and cron workers (server/internal/cmd/*.go). Business logic is strictly layered (api route structs → controller → logic → GoFrame DAO/model), with service interfaces registered via init() and RBAC enforced through JWT + Casbin middleware. The frontend is a Vue 3 + TypeScript + Naive UI + Pinia SPA whose routes are dynamically generated from backend menu permissions rather than hardcoded. The most distinctive feature — verified in code, not just docs — is the hggen code-generation engine: a vendored/forked GoFrame CLI that introspects MySQL/PostgreSQL schemas and emits DAO/entity/service/controller Go files, Vue CRUD views, API clients, and menu permission SQL from Go templates (server/resource/generate/default/*.template). The addon/plugin system (server/addons/hgexample as a full worked example) lets independent modules register their own routers, middleware, cron jobs, queue consumers, and WebSocket handlers.
This repository hosts a Chinese fan translation of the Japanese light novel series 'Re:Zero - Starting Life in Another World'. It is structured as an mdbook-based static website, with accompanying EPUB files, images, and a suite of Python scripts for crawling, translating, formatting, and building the content. The system includes CI/CD workflows (auto-build, auto-crawl, manual translation), a Dockerfile for containerized serving, and scripts for RSS feed generation, sitemap creation, and path fixing. The translation pipeline ingests raw Japanese text from web sources, applies translations, and produces organized markdown files that are compiled into a searchable online book with character pages, donation links, and external references. While primarily a content delivery application, it also has data-processing characteristics due to the ETL-like translation workflow. The codebase is well-structured with modular Python utilities and shell scripts, indicating active maintenance and a clear architecture.
Badge Magic is a cross-platform Flutter application for programming LED name badges over Bluetooth Low Energy and for flashing their firmware over USB. In production, users compose text, freehand drawings, clipart, GIFs, and dozens of animations; apply flash/marquee/invert effects and speed/mode settings; then serialize the composed badge into a proprietary LED hex format and transmit it as BLE packets to a badge. The app also reads and writes badge slots, saves/loads badges as local JSON files, shares/imports badges via a gzip-compressed QR code scheme, and updates WCH microcontroller firmware on Android/Linux through a custom MethodChannel and OS-specific ISP binaries. Architecturally it is a standard Flutter app using Provider for state management and GetIt for service location, with a clear split between UI screens, state providers, and utility modules. The most interesting part is the protocol path: internal models are converted to LED-matrix hex data, then to BLE byte packets via DataToByteArrayConverter, and finally written through a scan/connect/write/completion BLE state machine using universal_ble. Unit tests cover byte utilities, converter logic, clipart processing, and packet generation. CI/CD spans Android, iOS, Linux, macOS, Windows, and web. Some areas show accumulated drift: several ARB locale files are empty, custom animation logic is duplicated between preview and transfer implementations, debug logging remains in production code, and the firmware release URL is hardcoded.
This repository packages Zigbee2MQTT as a Home Assistant addon, providing Docker images, configuration schemas, and entrypoint scripts to run the Zigbee-to-MQTT bridge within Home Assistant's supervisor environment. It includes two addons: a stable/edge Zigbee2MQTT addon that builds from source, and a proxy addon that reverse-proxies to an external Zigbee2MQTT instance. The codebase is primarily infrastructure-as-code (Dockerfiles, shell scripts, CI workflows, addon configuration JSON) with no application logic of its own—the actual Zigbee2MQTT software is fetched and built during Docker image creation. The repository demonstrates solid Home Assistant addon development practices: multi-stage Docker builds, bashio-based configuration handling, socat support for serial-over-TCP, and automated CI/CD for multi-architecture images. However, it is tightly coupled to the Home Assistant addon ecosystem and offers no reusable software components outside that context.
This repository packages [code-server](https://coder.com) (VS Code running on a remote server, accessible through the browser) as a Docker image following LinuxServer.io conventions. It provides a complete container with s6-overlay init system, supporting both amd64 and arm64 architectures. The image includes optional password authentication, sudo access, proxy domain configuration, and PWA app naming. The core logic resides in the Dockerfiles (which fetch the official code-server tarball from GitHub releases) and the s6 service scripts that configure the runtime environment, manage permissions, and start the code-server process. The repository is part of the LinuxServer.io ecosystem and uses their standardized build pipeline (Jenkins, GitHub Actions) for automated builds, testing, and multi-registry publishing. It is a straightforward, well-maintained Docker packaging project with no application-level code beyond the containerization layer.
This repository is not a software application, service, or data pipeline; it is a curated awesome-list of open-source multiparty computation (MPC) resources, stored almost entirely as a single Markdown document plus contribution and code-of-conduct files. The core artifact, readme.md, categorizes roughly 100 projects and educational materials into Theory (books, courses, tutorials), Software (apps, frameworks, primitives, protocols, tools, retired software), and Workshops. Each entry includes a concise description, links to relevant academic papers, and maintenance context. There is no executable code, no package manifest, no CI configuration, and no tests; the repository's real architecture is its taxonomy and the editorial rules in contributing.md.
This repository implements a complete 16-bit computer simulator built from fundamental logic gates (NAND, AND, OR, etc.) in Go. It includes a CPU, memory, ALU, memory-mapped I/O (keyboard and 240×160 pixel display), and a custom instruction set. The project provides three command-line tools: a simulator that loads binary programs and runs them with a GLFW-based graphical window, an assembler that converts a custom assembly language into binary, and a program generator that produces example assembly programs (e.g., text writer, sine wave animation, snake brush). The system is a faithful gate-level simulation—every component from bits to the CPU is wired together using Go structs, making it an educational tool for understanding computer architecture.
QuickFIX is a production-grade FIX (Financial Information eXchange) protocol engine written in C++ with SWIG-generated bindings for Python and Ruby. It implements FIX session management (initiator/acceptor), message parsing/serialization, sequence number handling, heartbeats, resend requests, and message persistence (file, MySQL, PostgreSQL, ODBC). The library supports FIX versions 4.0 through 5.0 SP2 and FIXT 1.1, with auto-generated message classes from XML specification files. Architecturally, it is a library/framework—applications subclass the `Application` interface and use `Session::sendToTarget` to send messages. The network layer uses select()/poll()-based event loops (SocketMonitor) or threaded connections (ThreadedSocketConnection), with optional SSL/TLS support via OpenSSL. The codebase is mature and widely used in the financial trading industry, with extensive acceptance test definitions for each FIX version and language-specific unit tests. While the core abstractions (FieldMap, Session, DataDictionary) are well-designed, the repository suffers from significant code duplication across FIX versions, heavy conditional compilation, and some outdated patterns (auto_ptr, old-style platform detection). The code generation pipeline (Ruby scripts in spec/) is a notable reusable asset.
This repository is a Chinese-language web security handbook, organized as a modular knowledge base rather than a deployable software product. It contains three knowledge layers: `vul/` (vulnerability principles), `exp/` (exploitation playbooks with raw payloads, bypasses, and version-specific CVE chains), and `penetration/` (pentest methodology from recon to post-exploitation). The content is intentionally machine-consumable: `AI-MAP.json` provides a topic→document index with aliases and keywords, `AI-WIKI.md` and `AGENTS.md` instruct AI coding agents on how to retrieve and maintain the material, and `README.md` serves as the human quick-reference matrix. The primary operational use is as a field manual for penetration testers, red teamers, and CTF players: it includes byte-exact request smuggling payloads, SSTI engine fingerprinting tables, Java/PHP/.NET deserialization gadget chains, SQL injection dialect differences, WAF bypass catalogs, and Active Directory/Kerberos attack notes. Although defensive topics such as authentication logic and crypto misuse are covered, the dominant voice is offensive. The code footprint is small: `scripts/check-consistency.py` validates the index and links in CI, and `penetration/logtamper.py` is a legacy Python 2 log-clearing utility. As a knowledge asset, the repo is well-crafted: documents follow a consistent template, cross-link extensively, and are backed by a consistency checker and GitHub Actions workflow. However, it is not a software library or service: there is no API, no package, and no runtime to deploy. Version-sensitive exploit content and some aging tool references should be validated before use. Offensive material is intended only for authorized security testing.
GraphQL Zeus is a TypeScript-first GraphQL client generator that produces a fully type-safe query builder from any GraphQL schema. It provides a CLI tool (`zeus`) that accepts a GraphQL schema file or introspection URL and generates a complete TypeScript client with zero runtime dependencies beyond `cross-fetch` and `ws` (for subscriptions). The generated client supports multiple transport modes: standard HTTP via `Chain` and `Thunder` (with custom fetch injection), WebSocket subscriptions (both legacy and `graphql-ws`), and Server-Sent Events (SSE). It also offers integration helpers for Apollo Client (`typedDocumentNode`) and exports reusable selection set composition via `Selector`. The monorepo is structured into three packages: `graphql-zeus` (CLI orchestration), `graphql-zeus-core` (code generation engine and runtime functions), and `graphql-zeus-jsonschema` (JSON Schema generation from input types). The code generation pipeline parses the schema into a tree structure, then templates it into TypeScript types and runtime functions. The project is moderately well-maintained with active issues and a test suite focused on the core code generator, though the CLI lacks automated tests and the build tooling relies on the deprecated `ttypescript` package, indicating some technical drift.
Zui (formerly Brim) is an Electron-based desktop application for network security monitoring and data exploration. It provides a graphical interface to query and visualize data stored in a Zed/SuperDB lake, with a focus on Zeek and Suricata log analysis. The application supports importing packet captures (pcap), structured logs (Zeek TSV, NDJSON, CSV, Parquet), and offers a rich query editor (Monaco), histogram, table/inspector views, and export workflows. The codebase is a monorepo (Yarn workspaces, Nx) with packages for type definitions (`superdb-types`), a Node.js client (`superdb-node-client`), sample data, and an e2e test framework (`app-player`). The architecture follows a domain-driven pattern with handlers and operations, a Redux store with versioned state migrations, and a plugin system for extensibility. While the application is actively maintained and functionally rich, it exhibits some technical drift due to a mix of legacy and modern patterns, a large migration history, and tight coupling between core and plugins.
PiLiDAR is a DIY 360° 3D panorama scanner application for Raspberry Pi. It integrates a LiDAR (LD06/STL27L), stepper motor, IMU, and Raspberry Pi camera to capture 2D scans and photos, then processes them into colored 3D point clouds and 360° panoramas. The system is orchestrated by a main Python script (PiLiDAR.py) that controls hardware, captures data, and runs post-processing pipelines. The codebase is modular with a library of device drivers, calibration utilities, and 3D processing functions. It supports hardware PWM via curve-fitted speed control, automatic exposure and white balance calibration, Hugin-based panorama stitching, and Open3D-based point cloud registration, meshing, and visualization. The architecture is monolithic but well-organized, with clear separation of concerns. Key strengths include robust LiDAR protocol handling, reusable stepper motor control, and a comprehensive point cloud processing pipeline. The project is actively maintained with recent commits and low technical drift, though it requires specific hardware and external tools (Hugin, rpicam-still) to function.
This repository provides the Bench2Drive benchmark for closed-loop end-to-end autonomous driving, accepted at NeurIPS 2024 Datasets and Benchmarks Track. It includes a large-scale multi-modal dataset (up to 7.3TB) collected in the CARLA simulator, an evaluation suite with metrics like Driving Score and Success Rate, and baseline results for over 10 methods. The codebase is a hybrid of research data pipeline and application: the dataset generation and evaluation scripts form the core data_research component, while the B2DVisualize Flask app, scenario runner, and leaderboard evaluator provide application-like interfaces for interaction and reproducibility. Data lineage: raw simulation data (sensor recordings, ground truth annotations) is collected via data_collect.py, transformed into compressed archives with JSON manifests, and evaluated using the leaderboard pipeline that computes multiple ability metrics. The repository answers research questions about the effectiveness of end-to-end driving policies under diverse urban scenarios.
FFXIV Teamcraft is a large full-stack companion application for Final Fantasy XIV, used by players to plan crafting, track gathering, set in-game alarms, manage gear sets, browse item databases, and coordinate community crafting lists. The production system consists of an Angular 18 web client, an Electron desktop shell with packet-capture capabilities, a NestJS API, and a Firebase backend (Firestore, Auth, Cloud Functions). The client is the dominant surface: NgRx state modules, RxJS-heavy services, and dozens of standalone Angular components implement everything from a crafting simulator to fishing report overlays and inventory optimization. An associated data-extraction pipeline converts FFXIV game files and external APIs into static JSON assets consumed by the client, making this a hybrid application with a significant data-engineering component embedded in the broader product architecture. Primary data flows are: (1) static game data generated by extractors and loaded through a lazy-data facade; (2) user-generated content persisted in Firestore through generic storage abstractions; (3) live game telemetry captured by the Electron app via pcap and reported to internal GraphQL/REST endpoints; and (4) marketboard data pulled from Universalis. The codebase is organized as an Nx monorepo with shared `libs/types`, `libs/data`, `libs/search`, and `libs/simulator` packages. External dependencies include Firebase, Apollo GraphQL, ng-zorro, Flex Layout, flexsearch-ts, and multiple FFXIV community services (XIVAPI, Garland Tools, Universalis, Etro). Architecturally, the code is professional but carries significant technical debt. It mixes old class-based NgRx actions with modern `createAction`/`createEffect` APIs, blends standalone components with legacy NgModules, and duplicates domain models across `libs/types` and client modules. There are commented-out implementations, disabled tests, hardcoded game constants, and a handful of fragile extractor scripts. Still, the core abstractions—Firestore storage wrappers, lazy-data loading, base component classes, RxJS utilities, and a generic folder-tree facade—are solidly designed and reused extensively. The project is actively maintained, evidenced by recent commits, but the pace of feature work has left some cleanup and modernization incomplete.
GNvim is a GTK4-based Neovim GUI written in Rust. It communicates with Neovim via the MessagePack-RPC protocol, providing a native desktop experience with features like floating windows, popup menus, tabline, cmdline, and smooth animations for cursor and scrolling. The architecture is a single Rust binary split into a workspace: the main `ui` crate contains the GTK4 frontend with custom widgets (e.g., Grid, GridBuffer, Cursor, Fixedz, Popupmenu, Shell), and the `nvim-rs` library crate provides a reusable, async RPC client for Neovim with auto-generated API bindings. The system's entry point is `ui/src/main.rs`, which registers resources and launches the GTK application. Data flows bidirectionally: Neovim sends UI events (redraw, options, notifications) as RPC messages, which are deserialized into Rust types and applied to the GTK widget tree; user input (keyboard, mouse) is captured by GTK event controllers and sent back to Neovim as RPC calls. The codebase is well-structured, modular, and follows modern Rust async patterns, with extensive use of GTK4's property system and custom layout managers for complex UI composition.
MyBatisCodeHelper-Pro is an IntelliJ IDEA plugin that provides comprehensive MyBatis development support, including code generation from database schemas, method-name-to-SQL translation, real-time SQL auto-completion and correctness checking, MyBatis XML/Java interface navigation and refactoring, OGNL expression support, and a built-in MCP (Model Context Protocol) server for AI coding assistants. The repository contains only documentation, screenshots, and Velocity code-generation templates; the actual plugin source code is not included in this snapshot. Based on the extensive changelog and feature documentation, the plugin is actively maintained, supports recent IntelliJ versions, and offers a rich set of features for MyBatis developers. However, without access to the source code, the assessment of code craftsmanship and reusability is limited.