This repository is a documentation generation system used by Le Wagon to produce platform-specific setup guides for their Data Science & AI Bootcamp. It is a Ruby CLI tool that reads YAML build specs, combines reusable markdown partials (both local and remote), and outputs fully-formed setup instructions for macOS, Windows, Linux, and virtual machines in English and Spanish. The core architecture uses a Liquid templating engine, a partial cache for performance, and a clear separation between build definitions and localized output. The CI pipeline automatically rebuilds guides on push and commits any changes. While the repo does not contain any application or research code, its Ruby build system – particularly the remote partial fetcher with locale fallback and the centralized constants configuration – demonstrates clean, reusable patterns for any project that needs to generate multilanguage, platform-targeted documentation from composable snippets.
This repository is a comprehensive, interactive documentation website (handbook) for LLM inference, built with Docusaurus. It covers the full stack from hardware selection to kernel optimization, with embedded calculators, visualizers, and simulators. The content is heavily branded by Modular (MAX/Mojo ecosystem) and serves as both a technical reference and a product funnel. The codebase is well-structured with a custom design system, but the interactive components are tightly coupled to the Docusaurus framework and the specific educational content, limiting reusability. The repo is actively maintained and uses modern web technologies. It is not a data research project; it is a static web application for education.
GraphQLSwift/GraphQL is a Swift implementation of the GraphQL query language, ported from the JavaScript reference implementation graphql-js. It provides a complete runtime for parsing, validating, and executing GraphQL queries, mutations, and subscriptions. The library is designed to be embedded in Swift server applications, with companion packages for HTTP integration (graphql-vapor, graphql-hummingbird). It includes a full type system (Object, Interface, Union, Enum, InputObject, Scalar), schema building from SDL, introspection support, and a comprehensive set of validation rules that enforce the GraphQL specification. The architecture follows the graphql-js structure with modules for Language (lexer, parser, AST, printer, visitor), Type (schema, types, directives, scalars, introspection), Execution (query execution, subscription), Validation (validation rules, context), Utilities (schema building, type info, value from AST), and Map (dynamic value representation, JSON encoding). The library uses a visitor pattern for AST traversal and validation, and provides a Map type for handling dynamic GraphQL values with ordered dictionary semantics. Key features include support for persisted queries, subscription fields via AsyncThrowingStream, custom scalar types, and schema extension. The codebase is well-tested with extensive unit tests and benchmarks. However, some features are incomplete (e.g., variable directives, certain validation rules) and there is code duplication between AnyCoder and MapCoder. The library is actively maintained and follows the GraphQL specification closely, though it may lag behind the latest spec changes.
Evolution API is a production-grade, multi-tenant WhatsApp API gateway built with Node.js, TypeScript, and Express. It manages independent WhatsApp instances via Baileys (WhatsApp Web), Meta Business API, and its own Evolution API channel, providing REST endpoints for messaging, chat management, groups, labels, and media. The system integrates deeply with chatbot platforms (Typebot, OpenAI, Dify, Flowise, N8N, EvoAI, EvolutionBot) and event systems (Webhook, WebSocket, RabbitMQ, SQS, NATS, Kafka, Pusher), and includes storage via S3/MinIO and CRM sync with Chatwoot. The architecture follows a modular controller-service pattern with Prisma ORM (supporting MySQL and PostgreSQL), Redis caching, and centralized configuration. It is actively maintained with frequent updates, extensive migrations, and CI/CD pipelines.
This repository is a curated collection of Markdown files providing detailed, step-by-step instructions for configuring privacy and security settings across a wide range of software, operating systems, and online services. It covers desktop and mobile browsers (Brave, Firefox, Chrome, Edge, Vivaldi), operating systems (Windows 10/11, Android versions, macOS Sequoia), messaging apps (Signal, WhatsApp, Telegram), social media (Facebook, Instagram, Reddit, Twitter), and many other tools. The content is organized alphabetically, with each file containing screenshots (referenced but not included in the repo), notes, and tips. There is no executable code or build system; the repository is purely documentation. It serves as a reference guide for users seeking to minimize data collection and tracking. The project is actively maintained, with frequent updates tracking changes in the latest versions of the covered software.
Ultrachromic is a CSS theme for the Jellyfin media server that provides a modular system of CSS overrides to customize the appearance of the Jellyfin web interface. It consists of multiple CSS files that can be imported in a specific order to build a theme, including base styling, accent colors, rounding, progress bars, and various visual effects. The theme uses CSS variables for easy customization and includes presets that replicate the appearance of older chromic themes. It demonstrates good use of modern CSS features such as CSS variables, animations, backdrop-filter, and media queries.
e18e/cli is a command-line tool that analyzes JavaScript and TypeScript projects for packaging issues, dependency health, and opportunities to replace dependencies with lighter or native alternatives. It runs multiple checks: publint for publishing best practices, dependency replacement suggestions from curated manifests (native, preferred, micro-utilities), core-js polyfill analysis against declared engine ranges, duplicate dependency detection, and web feature codemod suggestions. The CLI also includes a `migrate` subcommand that can automatically apply codemods to rewrite imports for selected replacements. The architecture is plugin-based: each analysis is a self-contained `ReportPlugin` that receives an `AnalysisContext` and returns messages and stats, aggregated by a `runPlugins` orchestrator. The tool uses an abstract `FileSystem` interface with a `LocalFileSystem` implementation, making it extensible for custom environments. Output is either an interactive TUI via @clack/prompts or JSON. This is a pre-1.0 project, actively developed with good code quality and comprehensive tests.
Mindolph is a desktop knowledge management application built with JavaFX. It provides integrated support for mind maps, markdown, PlantUML diagrams, and CSV files, along with AI-powered features such as text reframing, summarization, and chat via various LLM providers. The application features a modular architecture with core, base, FX, and domain-specific modules, an event-driven communication system, a plugin/extension system for mind map operations, and a preference management system. Users can manage workspaces, search within files, and use reusable snippets.
PVE Tools is an interactive Bash toolbox for Proxmox VE 9.x administration. It provides a menu-driven CLI that wraps native PVE commands (qm, pct, vzdump, pvesm, pveceph) to reduce human error on high-risk operations by enforcing typed confirmation, automatic timestamped backups, and audit logging. In production, it is used to manage kernel installation/cleanup, GPU passthrough (Intel/NVIDIA/AMD), VM/CT backup/restore/snapshot, networking (bridges/bonds/VLANs/firewall), storage (local-lvm, Ceph, mount wizard), security hardening (SSH, CVE patches), and third-party integrations (CoolerControl, IT87 driver). The codebase is built from a modular source tree via build.sh and distributed as a single self-contained shell script. Architecture: The system is a single-file interactive CLI application delivered through GitHub Releases and CNB CDN. The launcher (PVE-Tools.sh) fetches the latest script or runs from a local install. Runtime control flows through lib/runtime.sh (main menu loop) and lib/menu.sh (generic menu framework). Eleven functional modules under src/modules/ each have an init.sh menu entry and dedicated sub-scripts. All file modifications are idempotent via marker-based blocks (apply_block/remove_block) and GRUB parameter helpers. The build process (build.sh) concatenates lib/ and modules/ in a fixed order; dev.sh sources them directly for development. Key entry points: PVE-Tools.sh (remote/local execution), dev.sh (development), and each module's init.sh (feature selection). External dependencies include Proxmox VE 9.x commands, systemd, GRUB, modprobe, and third-party GitHub repositories for module marketplaces and drivers. This is primarily an application for system administrators; no data pipelines, notebooks, or analytical schemas exist. The repository is hybrid only in the sense that it performs data operations (backup/restore of configurations) and includes a few standalone tools (mirror-test.mjs, cleanup scripts), but its dominant character is an interactive administrative tool.
This repository provides a library and build-time plugin for embedding a React (or Preact / React Native Web) web application inside a React Native WebView, with automatic bundling and two-way communication between the native and web sides. It consists of a Metro transformer plugin that uses Babel AST analysis to detect entry files (those calling webViewRender or webViewCreateRoot), then bundles the web app via esbuild with custom asset loaders for images, CSS, JSON, text, Markdown, and WebAssembly. The bundled output is wrapped in an HTML string and returned as the module source, which is then loaded into a react-native-webview at runtime. The library exposes React hooks (useWebViewMessage for native, useNativeMessage and emit for web) that handle message passing via window.postMessage and ReactNativeWebView.postMessage. The architecture is a classic library + build plugin pattern, with clear separation between native (React Native) and web (React DOM) concerns. The codebase is TypeScript, has end-to-end Playwright tests with HTML snapshots, unit tests, and thorough type definitions. It is designed for rapid prototyping or features that require web-specific APIs (e.g., WebAssembly, contenteditable) without rewriting the entire UI for React Native.
spotify_sync is a CLI application that downloads Spotify-liked songs and playlists by matching them to Deezer equivalents via ISRC and downloading the matched tracks. It features a modular architecture with separate components for Spotify API interaction, Deezer matching/downloading, persistent data storage, and configuration management. Key features include multi-threaded downloading, scheduling, Pushover notifications, and Plex library scanning via Autoscan. The application supports multiple profiles for different Spotify accounts and includes robust configuration validation with legacy migration capabilities.
Enunciate is a build-time Java framework that generates API documentation, Swagger/OpenAPI specs, WSDL/XSD, and multi-language client libraries from annotated web service source code (JAX-RS, JAX-WS, JAXB, Jackson, Spring MVC). It operates as a Maven plugin or Ant task, using a plugin architecture where each technology (JAXB, JAX-RS, etc.) and output format (HTML docs, C# client, etc.) is a separate module discovered via Java SPI. The core engine scans source files, builds an internal API model using javac annotation processing, then renders templates (FreeMarker) to produce artifacts. The codebase demonstrates solid engineering with clear separation of concerns, but shows age: it targets Java 8, uses older library versions, and has significant duplication across client generation modules. It remains functional for legacy projects but may require updates for modern Java frameworks.
MTO-Platform (MToP) is a comprehensive MATLAB benchmarking platform for evolutionary multitasking (EMT). It provides a unified, extensible framework for defining optimization problems, implementing algorithms, and evaluating performance metrics. The platform includes over 50 multitask algorithms (e.g., MFEA, AT-MFEA, TRADE, SSLT), 200+ multitask problem cases (including CEC, WCCI, and real-world benchmarks), and 20+ performance metrics (IGD, HV, Spread, etc.). It supports single-task, multi-task, many-task, multi-objective, constrained, and competitive optimization scenarios. The system features both a graphical user interface (GUI) and a command-line interface, with parallel execution support and integration with external tools like IOHanalyzer and Python Gym environments for policy search. The architecture is modular: base classes (Problem, Algorithm, Metric) define consistent interfaces, and all components inherit from them. Utility modules (Individual, Initialization, Selection, Operator, Multi-objective sorting) are shared across algorithms, promoting code reuse. The codebase also includes real-world applications such as global trajectory optimization, optimal power flow, sensor coverage, and photovoltaic model parameter extraction. While primarily a research platform, it also serves as a library of reusable evolutionary computation components. The repository is actively maintained (v1.10, references to 2026) but exhibits some technical drift: use of deprecated MATLAB functions (textread), large vendored third-party code (SOM Toolbox), and binary .mat files that may cause compatibility issues. Code duplication exists in problem definitions and some algorithm utilities. Despite these issues, the platform is well-structured, extensively documented, and widely cited in the EMT literature.
MegaDetector is a production-grade object detection pipeline specifically designed for camera trap images in wildlife conservation. It detects animals, people, and vehicles in images and videos, outputting bounding boxes with confidence scores in a standardized JSON format (MegaDetector output format). The system provides a comprehensive set of command-line tools for batch inference, post-processing (repeat detection elimination, classification smoothing, format conversion), and integration with platforms like Wildlife Insights and LILA. The architecture is a modular Python package with separate modules for detection (supporting PyTorch and TensorFlow backends), classification, data management, post-processing, visualization, and taxonomy mapping. Key entry points include `run_detector_batch.py` for batch inference, `run_detector.py` for single-image inference, `postprocess_batch_results.py` for generating HTML previews, and `separate_detections_into_folders.py` for organizing results. Data flows from raw images through the detector to JSON results, which are then post-processed (e.g., false positive reduction, confidence thresholding) and optionally converted to other formats (COCO, YOLO, Wildlife Insights). External dependencies include PyTorch, TensorFlow, ultralytics, OpenCV, PIL, and various utility libraries. The repository also includes a C# Windows GUI application for JSON subsetting and integration guides for Timelapse and digiKam.
CloudMeet is a full-stack meeting scheduler (Calendly alternative) built entirely on Cloudflare's free tier. It uses SvelteKit for the frontend and server-side logic, Cloudflare D1 for the database, KV for caching, and Workers for cron-based email reminders. The application supports single-user (admin) operation with Google Calendar and Outlook Calendar integration, allowing attendees to book meetings that automatically create calendar events with video conferencing links (Google Meet or Microsoft Teams). It includes a comprehensive email notification system via Emailit API, customizable availability rules, event types, and a dashboard for managing bookings, profiles, and email templates. The architecture is a monolith deployed to Cloudflare Pages with a separate cron worker for reminders. The codebase demonstrates solid engineering practices: TypeScript throughout, well-structured caching layer with KV and browser cache, request coalescing, input validation, and a modular email template system. It is not a data research project; it is a production-ready application.
The JPImageresizerView repository is an iOS library for cropping images, GIFs, and videos. It provides a customizable cropping interface (JPImageresizerView) with support for rotation, mirroring, masks, borders, rounded corners, and various visual effects. The library is designed for flexibility through a fluent configuration pattern (JPImageresizerConfigure) and delegates processing to a core utility class (JPImageresizerTool) that handles asynchronous media transformations and caching. The architecture separates concerns into configuration, UI components, and processing logic. Key reusable components include the configuration builder, the interactive crop frame view (JPImageresizerFrameView), and the media processing tool. The library supports output formats such as JPEG, PNG, GIF, and video, and integrates with AVFoundation and the Photos framework for media handling. While the library is feature-rich and demonstrates solid engineering practices, it shows signs of technical drift due to the use of deprecated Objective-C APIs, manual memory management, and reliance on third-party libraries like Masonry and POP. Despite this, it remains maintained with regular updates and is compatible with iOS 11.0 and above.
This repository is a Laravel package that provides middleware for integrating with the IPinfo API to enrich HTTP requests with IP geolocation and related data. It supports multiple API tiers (Core, Plus, Lite, and Residential Proxy) and includes features like caching, IP selection strategies, bot filtering, and exception handling. The package follows Laravel conventions with service providers, facades, and configurable middleware. It is actively maintained with recent commits and supports Laravel versions up to 13. The codebase is well-structured, with clear separation of concerns and reusable components like the caching mechanism and IP selector interface.
Open Tournament is a first-person shooter game built on Unreal Engine, inspired by classic arena shooters like Unreal Tournament and Quake. The game implements comprehensive systems for player movement, combat, AI, user interface, audio, and networking. It features a modular architecture using Unreal Engine's plugin system, with extensive use of the Gameplay Ability System (GAS), Enhanced Input, and replication for multiplayer functionality. The codebase shows thoughtful architectural design in several reusable systems, particularly in settings management, UI composition, messaging, and loading screen handling.
This is a TypeScript-based danmaku (bullet screen/comment overlay) library for the web. It provides a manager-based architecture to push, render, and animate danmaku over video or any DOM container. The library offers two types of danmaku: facile (scrolling) and flexible (custom-positioned), with collision detection modes (none, strict, adaptive) and a track system for lane management. Rendering is done via CSS transitions, enabling rich customization and integration with any UI framework (the demo uses React). The library has a comprehensive plugin system via hooks-plugin, allowing developers to hook into lifecycle events at both manager and danmaku level. It is well-structured, with clean separation of concerns (Manager, Engine, Container, Track, Danmaku classes), and includes utility functions for expression-based size calculations. The demo application is a full-featured control panel for testing all configurable options. The repository also includes extensive documentation (VitePress) with both English and Chinese locales.
Aerugo is a safety-critical, cooperative Real-Time Operating System written in Rust for space applications, developed under an ESA activity targeting the Microchip ATSAMV71Q21 (ARM Cortex-M7). The code confirms a genuine, working RTOS: a non-preemptive executor schedules fine-grained type-erased tasklets by priority, alongside primitive event sets, message queues, boolean conditions, cyclic execution, and per-tasklet execution statistics with timeout events. It is designed for no_std, no-alloc, static-allocation environments, using a hand-rolled vtable instead of trait objects to avoid dispatch overhead. An x86 backend exposes the same APIs on the host for development and testing without the SAMV71 hardware. The repo is a Rust workspace: the core aerugo RTOS crate, a generic AerugoHal trait, a comprehensive SAMV71 HAL (SPI, UART, PIO, timer waveform channels, XDMAC DMA, watchdog, PMC clock config, FPU), a large svd2rust-generated Peripheral Access Crate, an x86 HAL stub, utility crates (bounded-int, bitfield-enum, lsm6dso IMU driver, env-parser), and example/demo applications including a CCSDS-based SPI accelerometer telemetry demo. The HAL makes strong use of the typestate pattern (e.g., Spi<NotConfigured> transitioning to Spi<Master>; UART reader/writer token ownership) to enforce correct hardware usage at compile time. The testing infrastructure is unusually strong for an embedded RTOS: the custom 'calldwell' Python harness orchestrates hardware-in-the-loop tests over SSH, GDB, RTT and UART, with SRS requirement IDs traceable to test cases. However, some design-level requirement tests are empty stubs, and the generated PAC contains artifacts including literal '[%s]' placeholder names in register descriptors. Requires nightly Rust (unstable tracked-environment proc macro), and at least one suspected clock-prescaler mapping bug exists in the PMC configuration code. Duplicated utility macros have already started to diverge between crates. Overall this is a professional-grade RTOS with several genuinely reusable components and elegant embedded Rust patterns, held back slightly by generated-code bloat, incomplete traceability stubs, and a narrow single-MCU focus.