Fityk is a cross-platform scientific data fitting program focused on nonlinear curve fitting, particularly peak fitting in spectroscopy and crystallography. It provides a core library (libfityk) with multiple fitting algorithms (Levenberg-Marquardt, MPFIT, Nelder-Mead, Genetic Algorithm, NLopt), a rich set of built-in peak functions (Gaussian, Lorentzian, Voigt, Pearson VII, etc.), symbolic derivatives via AST, and a bytecode VM for expression evaluation. The architecture is modular: a core library, a CLI with readline and gnuplot integration, a wxWidgets GUI, and scripting support via Lua and SWIG bindings for Python, Perl, Ruby, and Java. Key entry points include the Fityk class API, the command parser (cparser.cpp), the runner (runner.cpp), and the GUI main frame (frame.cpp). Data flows involve loading data from files (via xylib), defining models as sums of functions, fitting using least-squares optimization, and outputting parameters and statistics. External dependencies include wxWidgets, Boost, Lua, NLopt, xylib, readline, gnuplot, zlib, and SWIG. The codebase is well-structured with extensive documentation and tests, though it shows some age with pre-C++11 idioms and platform-specific workarounds.
This is a large, multi-language monorepo from X (formerly Twitter) containing the core code for the For You feed recommendation system. It includes real-time Rust services (home-mixer, thunder, vm-ranker), a Scala rule engine (botmaker) for spam/abuse detection, Python ML training infrastructure (phoenix/xrex), content safety pipelines (grox), and batch feature extraction jobs (simclusters, agatha). The system is composed of loosely coupled services communicating via thrift/gRPC and Kafka, with a strong emphasis on modular pipeline architectures (sources, hydrators, filters, scorers, selectors). While the code demonstrates high craftsmanship with clean abstractions and extensive use of traits/interfaces, it is deeply integrated with internal infrastructure (Manhattan, Strato, Finagle) and requires significant adaptation for external reuse. The repo is hybrid, containing both production application services and substantial ML research/training code.
Stoobly Agent is a CLI-driven HTTP proxy tool for recording, mocking, replaying, and testing API traffic. Built on mitmproxy, it intercepts HTTP/HTTPS requests and applies configurable policies across four modes: record, mock, develop, and test. The tool stores intercepted requests and responses in a local SQLite database via a custom ORM, and can also synchronize with the Stoobly cloud service for remote project management. It supports lifecycle hooks (user-defined Python callables), OpenAPI endpoint import, snapshot/rollback of request state, and a scaffold system that generates Docker Compose or local development environments for services and workflows. The architecture is modular, with clear separation between the CLI layer (Click-based), proxy interception handlers, data models and adapters (converting between mitmproxy, raw HTTP, ORM, and Stoobly API representations), and a settings system with YAML persistence and environment variable overrides. Key entry points include the main CLI group (stoobly_agent/cli.py), the proxy intercept handler (stoobly_agent/app/proxy/intercept_handler.py), and the scaffold commands (stoobly_agent/app/cli/scaffold/). External dependencies include mitmproxy for traffic interception, a custom ORM (stoobly_orator) for local storage, and the Stoobly cloud API for remote features. The codebase demonstrates strong software engineering practices with extensive use of design patterns (adapter, facade, builder, singleton, strategy) and a comprehensive test suite covering unit, integration, and end-to-end scenarios. While the scaffold system and snapshot management add complexity, the overall architecture is well-organized and the tool delivers a polished developer experience for API mocking and contract testing.
Specinfra is a Ruby library that provides a common abstraction layer for infrastructure testing tools like Serverspec and Itamae. It defines a unified API for running commands on remote or local systems, detecting the target OS, and generating OS-specific shell commands for checking system resources such as packages, services, files, ports, users, and more. The library supports multiple backends including local execution (Exec), SSH, Docker (via docker-api and CLI), LXC, LXD, WinRM, Telnet, and others, making it suitable for testing a wide variety of environments from bare metal to containers and cloud instances. The architecture is built around three core concepts: backends that handle command execution, commands that generate the appropriate shell commands for a given OS and resource type, and a processor that implements higher-level checks (e.g., whether a service is running, whether a file is mounted with specific options). OS detection is handled by a set of detectors that probe the target system and determine the family, release, and architecture. A command factory dynamically resolves the correct command class based on the OS info, allowing seamless support for over 20 Linux distributions plus BSD, macOS, Solaris, AIX, and Windows. While the codebase is mature and well-structured with clear separation of concerns, it is tightly coupled to the Serverspec/Itamae ecosystem and uses global configuration and singleton patterns. The command modules for service management (systemd, init, OpenRC, etc.) and port checking (using ss) are cleanly extracted as Ruby mixins and could be reused in other projects with minimal adaptation. The library is actively maintained, supports Ruby versions from 2.3 to 3.4, and has a comprehensive test suite covering command generation and OS detection.
PECmd (Prefetch Explorer Command Line) is the de facto standard DFIR tool for parsing Windows prefetch (.pf) files. It extracts the executable name, hash, run count and last-run timestamps, volume information, and directory/file references from every prefetch version including XPress/Huffman-compressed Windows 10/11 files, and renders results to the console, CSV (a per-file report plus a per-run timeline), JSON (one object per file, ISO 8601 UTC timestamps), or XHTML. Beyond basic parsing it can process Volume Shadow Copies (--vss via the ERZHelpers library's VSS mounting), scan NTFS alternate data streams for prefetch data hidden by ADS-executed binaries (--ads, including the empty-primary-stream edge case), deduplicate inputs by SHA-1, and save decompressed raw bytes (-o). The parsing core itself lives in the separate Prefetch NuGet package; this repository is the operational shell handling CLI parsing, file enumeration, VSS/ADS orchestration, error resilience, and all export formats. Architecture-wise this is a single C# project multi-targeting net472 and net10.0, built around one monolithic Program.cs (~1500 lines) that owns argument handling (System.CommandLine), recursive file discovery (AlphaFS on net472, a custom FileSystemEnumerator on modern .NET), export serialization (CsvHelper, ServiceStack.Text, XmlTextWriter), and Serilog console/file logging. The code is pragmatic and battle-tested rather than architecturally elegant: static mutable state (shared keyword set, failed-file list, processed-file list) and a god-file style limit modularity and testability (the project explicitly has no tests). What it lacks in structure it makes up for in domain rigor: read errors (access denied, locked files) are carefully distinguished from parse errors (damaged files reported but exit code 0; unreadable input yields exit code 1), unreadable folders are surfaced instead of silently skipped, and the Windows 10+ prefetch hash-validation quirk is handled with real forensic depth. Highlighted reusable logic: ExecutablePathResolver, a cleanly isolated component that resolves an executable's full path from prefetch file references and validates it against the file's hash — including iterating \DEVICE\HARDDISKVOLUME{n} candidates because Windows 10+ stores volume-GUID paths but hashes the native device path. Also notable is the private EntryFinder, a FileSystemEnumerator subclass that captures per-folder read errors during recursive walks without aborting — a genuinely non-obvious pattern worth extracting for any resilient file-walking tool. Maintenance is active (2026.10.3, embedded PDBs for deterministic stack traces, Exceptionless telemetry, SmartAssembly-protected release pipeline) and the README/CLAUDE.md documentation is unusually precise about intentional engineering trade-offs.
This repository is the source code for `@worktile/gantt`, an Angular component library for building interactive Gantt charts. It provides a rich set of components including the main Gantt chart, a table with columns, draggable bars, dependency links, ranges, baselines, and a toolbar. The library supports multiple time views (hour, day, week, month, quarter, year) with a pluggable view system allowing custom views. It leverages Angular CDK for virtual scrolling and drag-and-drop interactions. The architecture follows Angular's standalone component pattern with NgModule compatibility. Key data flows include immutable item updates (OnPush change detection), event-driven drag operations emitting typed events, and a service layer for scroll synchronization, printing/export via html2canvas, and global configuration via DI tokens. External dependencies are Angular >=22, Angular CDK, rxjs, date-fns, and @date-fns/tz. The library is actively developed with version 22.0.0 and has extensive bilingual documentation and a demo application.
MySQL Workbench is a production-grade, cross-platform desktop application for MySQL database management. Its codebase is organized into a modular architecture: a core C++ backend using the GRT (Generic Runtime) object model for metadata-driven object management and plugin loading; a cross-platform UI abstraction layer (mforms) with platform-specific implementations for Linux (GTK), macOS (Cocoa), and Windows (.NET); dedicated packages for data modeling (EER diagrams, forward/reverse engineering), SQL editing (syntax highlighting, autocompletion, query execution), server administration (user management, performance monitoring), and data migration. The repository also bundles a custom ANTLR-based SQL parser, a canvas library for interactive diagramming, SSH connectivity support, and extensive SQL scripts for Performance Schema monitoring. While it contains analytical SQL scripts for database diagnostics, its core nature is a graphical application, not a data research project.
AgentSkillsHub is a production full-stack web application: a security-graded, quality-scored directory of 117,000+ open-source AI agent skills, MCP servers, and agent tools, served from a React/TypeScript SPA with a Python FastAPI service layer and Supabase/PostgreSQL backend. Every 8 hours a GitHub Actions sync pipeline searches GitHub, enriches repo metadata, fetches READMEs, cleans and deduplicates, applies an 8-9 dimension quality score, and grades security into safe/caution/unsafe/reject/unknown tiers via a heavily-tuned rule-based scanner with an optional LLM pass. The frontend exposes search, filtering, compare, favorites, i18n (zh/en), static pre-rendered SEO pages, an admin panel, monetized Pro search, enterprise audit lead capture, and a verified newsletter flow. The public API (FastAPI plus Supabase RPCs) backs the SPA, using request deduplication, aggressive column minimization, and materialized cache tables to survive the load. The repo is application-dominant but genuinely hybrid with data research. An ops/ engine room runs controlled benchmark harnesses (PPT, video, guard-hooks, code review, anti-slop, Obsidian, skill managers) that execute third-party skills in Docker sandboxes, capture transcripts, judge outputs with LLM models under majority voting against ground-truth fixtures, and publish public evidence pages. A radar subsystem monitors X, Hugging Face, the App Store, and social memes to discover emerging tool terms with cost-budgeted API calls. The security scanner rule history and adjudication datasets (reported Jev-judge AUC 0.916 against labeled flag instances) read like an ML calibration project, and the SEO research folder contains extensive keyword, SERP, and competitor studies. Reusable high points: the log-normalized scoring engine, the README security scanner with citation-vs-issue disambiguation, the keyset-paginated batch-commit ETL pattern, the paced idempotent backfill queue, the request-collapsing SPA data layer, and an OpenAI-compatible sandbox image proxy for benchmarking agent skills without leaking API keys. The core pipeline is professionally tested (20+ unit test files, mostly pure-logic tests that run without a database). Caveats: it is effectively a single-maintainer operation with hardcoded personal paths, an admin token seeded in a committed migration, duplicate backend/migrations and supabase/migrations that can drift, many one-off ops scripts with duplicated env-reading code, and future-dated 2026 content plus hardcoded fallback data that can confuse. Despite the sprawl, the engineering discipline around the scanner, batch processing, rate-limit resilience, and RLS-based database security is well above typical directory-site quality.
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.
SJTU-Canvas-Helper is a desktop application built with Tauri (React frontend, Rust backend) that enhances the Shanghai Jiao Tong University Canvas learning management system. It provides file preview/download, assignment management, video handling (download, merging, live streaming, AI summarization), AI chat integration (with files, videos, and Canvas agent), SJTU Cloud/JBox integration, annual report generation, QR code login, and multi-account support. The architecture features a single-page React frontend with Redux for global state, communicating with a Rust backend via Tauri's invoke system for API interactions, file processing, and task management. Key external dependencies include Canvas API, SJTU Cloud API, video platform APIs, and LLM providers (e.g., DeepSeek) for AI features.
MiniRust is a formal specification of an idealized subset of Rust, known as MiniRust, with an executable model defined in a custom specification language (specr). The repository provides tooling that translates real Rust MIR (via rustc) into MiniRust and runs it through a reference interpreter. It includes a comprehensive test suite (minitest) covering pass, panic, and undefined behavior scenarios, along with utilities for program construction and pretty-printing. The work is squarely a formal-semantics research project, not a production application. It models pointer provenance, aliasing (Tree Borrows), concurrency, and data-race detection, and is primarily used to validate the Rust memory model. The codebase is well-structured with clean abstractions (pluggable memory model, builder API) but depends heavily on unstable rustc internals and has many incomplete features (e.g., floats, operators, casts).
Ham Dashboard is a browser-based web application that displays configurable content in a grid layout. It supports images (with rotation), videos, iframes (web pages), and RSS feeds. The application is built with vanilla JavaScript, HTML, and CSS, requiring no backend or build process. Configuration can be loaded from localStorage, config.js, config.json, or other JS/JSON files via URL parameters or file picker. Key features include a settings UI for configuration, full-screen viewing, right-click to rotate content, double-click to zoom, automatic content refresh, and breadcrumb-aware navigation between different dashboard configurations. The application is designed to be lightweight and easily hostable on static platforms like GitHub Pages or Cloudflare Pages.
Molecule is a lightweight Web IDE UI framework inspired by VSCode, built with React and TypeScript. It provides a customizable Workbench UI with core components (MenuBar, ActivityBar, Sidebar, Editor, Panel, StatusBar) and an extension system for adding functionality via plugins. The architecture follows a service-based pattern with dependency injection (tsyringe), separating concerns into models (state), views (React components), and controllers (business logic). Key features include Monaco Editor integration, theming, internationalization, and keybinding systems. The framework is designed for embedding in React applications to create IDE-like interfaces, with extensibility points for contributing UI, commands, themes, and languages.
extruct is a Python library for extracting embedded metadata from HTML markup. It supports six metadata syntaxes: W3C HTML Microdata, JSON-LD, Microformat (via mf2py), Open Graph, RDFa (via pyrdfa3/rdflib), and Dublin Core. The library provides a consistent extractor interface (`.extract()` and `.extract_items()`) and a CLI tool (`extruct`) that fetches a URL and outputs extracted metadata as JSON. The codebase is organized into modular extractors under `extruct/`, an orchestrating `_extruct.py` that dispatches to selected syntaxes, and a `uniform.py` module that flattens results into a common schema. The primary entry points are the `extruct.extract()` function and the `extruct.tool:main` console script. Architecturally, each extractor is a standalone class that parses an HTML string (or lxml tree) and yields JSON-serializable dictionaries. The JSON-LD extractor is notably robust, implementing a multi-stage repair pipeline to handle malformed input commonly found in the wild (HTML/JS comments, CDATA, unescaped quotes, trailing junk). The RDFa extractor wraps pyRdfa with workarounds for ordering and namespace issues. The Microdata extractor implements the W3C algorithm using lxml XPath with EXSLT set operations. The Open Graph extractor uses prefix-attribute matching with a hardcoded namespace map. The Dublin Core extractor maps large element/terms vocabularies. External dependencies include lxml (HTML parsing), rdflib and pyrdfa3 (RDFa), mf2py (Microformat), jstyleson (JSON repair), html-text (text extraction), and w3lib (URL utilities). The library is designed for web scraping and crawling pipelines, where extracting structured data from HTML is a common need. It is published on PyPI and maintained by Scrapinghub. The test suite is extensive, with over 100 HTML fixtures organized by source (schema.org, W3C, Songkick, Wikipedia, custom invalid cases). Tests cover edge cases like malformed JSON-LD, namespace variations, and real-world pages. The codebase shows signs of age in some areas (RDFa hacks, stale references to removed modules, filtered deprecation warnings), but remains functional and well-tested.
HASSL (Home Assistant Simple Scripting Language) is a domain-specific language compiler that translates human-readable .hassl scripts into YAML automation packages for Home Assistant. The compiler parses the DSL using Lark, builds an AST, performs semantic analysis (including alias resolution, import handling, template expansion, and schedule validation), and generates multiple YAML files (helpers, scripts, sync automations, rule automations, schedule sensors) that can be directly loaded into Home Assistant. The architecture follows a classic compiler pipeline: parsing → transformation → analysis → code generation, with clear separation between modules. The system supports modular packages with imports, public/private exports, rule templates, time-based schedules (including sunrise/sunset, weekday/weekend/holiday windows), event-driven conditions (button presses, event entities), loop-safe context tracking, and rule arming. The CLI tool `hasslc` compiles single files or directories, automatically resolving cross-package dependencies. The codebase includes a comprehensive test suite (32 tests) covering parsing, IR generation, and YAML output. While primarily an application, the repository also includes developer tooling such as an Emacs major mode for the DSL and utility scripts for Home Assistant entity discovery. The compiler is implemented in Python with minimal external dependencies (lark-parser, jinja2, pyyaml) and is designed for extensibility.
Intel ISA-L Crypto is a production-grade, high-performance cryptographic library optimized for storage and networking workloads. It provides software implementations of AES (CBC, GCM, XTS), multi-buffer hashing (SHA1, SHA256, SHA512, MD5, SM3), multi-hash parallel hashing, rolling hash for content-defined chunking, and FIPS 140 self-tests. The library is not an application but a low-level C library with assembly (x86 SSE/AVX/AVX512/VAES/AVX10, ARM NEON/SVE/SVE2, RISC-V RVV) to maximize throughput on modern CPUs. The codebase is organized by algorithm (aes/ sha1_mb/ mh_sha1/ rolling_hash/) with architecture-specific subdirectories. It uses a robust multi-buffer job manager pattern (init/submit/flush) for all hashing algorithms and a multibinary dispatcher to select the optimal SIMD variant at runtime. Extensive test suites (standard vectors, random, streaming, performance, fuzz) validate correctness against OpenSSL and NIST vectors. The library is actively maintained, supports multiple build systems (autotools, cmake, nmake), and includes CI for Linux, Windows, ARM64, and RISC-V. While the code is professionally engineered with high performance as the primary goal, it suffers from significant duplication across hash algorithms and ISA variants, making maintenance and extraction of individual components non-trivial. It is not a general-purpose crypto library but specifically targets scenarios requiring maximum throughput on Intel and ARM processors, making it ideal for integration into storage appliances, network appliances, and DPDK-based packet processing.
Luet is a container-oriented package manager written in Go that builds, distributes, and installs binary packages on Linux systems. It leverages container runtimes (Docker or Buildah) as build backends and OCI images as a distribution format, enabling features like layer caching, delta updates, and rootfs versioning. The system uses a SAT solver (gophersat) for dependency resolution, with an optional reinforcement learning (QLearning) strategy, and supports multiple repository types (disk, HTTP, Docker registries). Its package definitions are YAML-based with Helm-like templating, collections, and finalizers (post-install scripts). The CLI exposes commands for building, installing, upgrading, searching, and serving repositories, along with utilities for repository creation and database management. The architecture is modular: a compiler backend abstraction, template engine, version comparator (Debian semantics), in-memory/BoltDB package databases, and a file-index-based system tracker. Integration tests cover realistic workflows (install, upgrade, conflict resolution, config protection) using shUnit2 and Docker fixtures. While the codebase is well-structured with strong test coverage, some legacy dependencies (asdine/storm, ghodss/yaml, pkg/errors) and a deprecated `img` backend alias indicate moderate technical drift, though the project is actively modernizing (Buildah backend, Docker 29 compat, cross-arch support).
This is a hardware/software co-design repository for the BSG Manycore accelerator, a tiled manycore processor with custom RISC-V RV32IMAF cores (vanilla_bean), a 2D mesh or ruche network-on-chip, and a multi-level memory hierarchy (local DMEM, shared DRAM via vcache). The software stack includes an SPMD programming model with a CUDA-like runtime, synchronization primitives (barriers, mutexes, MCS locks), and a library for remote memory access and tile-group operations. Extensive simulation and verification infrastructure is provided, including Verilator/VCS testbenches, profiling hooks (PC histograms, vcache stall analysis, energy estimation), and a Python analysis toolkit for trace and stats parsing. The repository targets both FPGA emulation and ASIC tapeout (multiple 16nm/12nm chips have been fabricated). While primarily a hardware platform, it also serves as an architecture research vehicle with microbenchmarks for performance and energy characterization. The codebase is well-structured but contains some deprecated directories and old toolchain patches, reflecting its research-group origins.
axum-login is a Rust library providing user identification, authentication, and authorization as tower middleware for Axum web applications. It enables pluggable authentication backends through well-designed traits (AuthUser, AuthnBackend, AuthzBackend) and offers flexible route protection via both macro-based and builder-based middleware APIs. The library uses tower-sessions for secure session management and includes features like session fixation mitigation and constant-time password verification. Examples demonstrate usage with various backends including SQLite, OAuth2, and permission-based systems.
This is the BigCommerce Cornerstone reference theme for the Stencil platform, a fully responsive e-commerce storefront. It provides a complete set of pages for product browsing, cart management, checkout, account management, search, and more. The theme is built using Handlebars templates for server-side rendering, JavaScript for client-side interactivity, and SCSS for styling, with a component-based architecture. The JavaScript architecture uses a PageManager base class with page-specific controllers (e.g., Cart, Product, Category) that are dynamically loaded. Key reusable components include a modal with focus trap, collapsible panels with ARIA support, an accessible carousel, faceted search, and form validation utilities. The theme emphasizes accessibility with extensive ARIA attributes and keyboard navigation. The theme is highly configurable via a schema.json that defines hundreds of settings (colors, fonts, layout options) and supports multiple locales through translation files. It integrates with BigCommerce's Stencil CLI and uses modern build tools (Webpack, Babel) alongside legacy ones (Grunt). While primarily a frontend theme, it includes performance optimizations like lazy loading, code splitting, and polyfill-on-demand.