AnonAddy (addy.io) is a self-hosted anonymous email forwarding service built with Laravel, Inertia.js, and Vue 3. In production, it allows users to create email aliases that forward to real inboxes, with support for custom domains, PGP/MIME encryption, user-defined rules (sender/subject/header conditions with actions like block, quarantine, label), and a blocklist. The system receives inbound email via a Postfix pipe, applies rules, and either forwards, replies, or sends-from aliases with rewritten headers, List-Unsubscribe banners, and optional DKIM signing. Outbound sending handles VERP bounce tracking and stores failed deliveries with deduplication. The architecture is a monolith Laravel application with a REST JSON API (used by mobile/extension clients) and a server-driven SPA frontend. Key entry points include the ReceiveEmail console command, the CustomMailer driver, and numerous API controllers under /api/v1/. The frontend uses reusable Vue components and Inertia form handling across pages for alias, recipient, domain, rule, blocklist, and settings management.
This repository is a framework-agnostic drag-and-drop library developed by FormKit. It provides a data-first approach where consumers manage a reactive array as the source of truth, and the library handles DOM reordering internally. The core is written in TypeScript and is small (~4KB gzip), with first-class adapters for React, Vue, Solid, and Marko. The architecture consists of a central state machine using WeakMap stores to associate DOM elements with drag state, an event emitter pattern for global and parent-level events, and a plugin system for extensibility (animations, drop-or-swap, insert). Key entry points include the `dragAndDrop` function and framework-specific hooks/composables (e.g., `useDragAndDrop` for React). The library supports native HTML drag-and-drop and synthetic pointer-based dragging for touch devices, with features like multi-drag, drag handles, shadow DOM, and configurable animations. External dependencies are minimal—only peer dependencies for framework adapters and optional Marko runtime. The repository also includes a comprehensive Playwright test suite covering sorting, transfer, animations, and edge cases, plus a Nuxt-based documentation site with live examples for all supported frameworks.
llama.rn is a React Native native module that wraps llama.cpp to provide on-device LLM inference on iOS and Android. It exposes a comprehensive TypeScript API via JSI for text completion, chat, embeddings, reranking, decision models, text-to-speech (multiple families), multimodal (vision/audio), speculative decoding (MTP), parallel decoding, tool calling, and state checkpointing. The architecture features a C++ core (slot manager, completion engine, TTS pipeline, decision evaluator) bridged to JS through direct JSI bindings, with GPU backends including Metal (iOS), OpenCL (Android), Vulkan, and Hexagon NPU (experimental). The library is production-grade with CI/CD, prebuilt binary distributions, and a full-featured example app demonstrating all capabilities. It is maintained by BRICKS and actively synced with upstream llama.cpp via vendoring and patch scripts.
The Fusion Transpiler (fut) is a self-hosted compiler that translates Fusion source code (.fu) into multiple target languages: C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript, and OpenCL C. It is a command-line tool that reads Fusion source files, performs lexical analysis, parsing, semantic analysis, and then emits equivalent source code in the requested target languages. The compiler itself is written in Fusion and bootstrapped via committed generated files (libfut.cpp, libfut.cs, libfut.js). The architecture follows a classic compiler pipeline: Lexer.fu (FuLexer) -> Parser.fu (FuParser) -> Sema.fu (FuSema) -> GenBase.fu and per-target generators (GenC.fu, GenCpp.fu, GenCs.fu, etc.). The AST is defined in AST.fu. The system includes a preprocessor (#if/#elif/#else/#endif) and supports conditional compilation per target. Key entry points: The CLI hosts (fut.cpp, fut.cs, Fut.java, fut.js) parse command-line arguments and invoke the compiler pipeline via ConsoleHost.fu (FuConsoleHost.Emit). The generated libfut.hpp exposes the full compiler API for embedding. The LSP server (editors/lsp/lsp.fu) reuses the parser/sema for IDE features. The test suite (test/Runner.fu) runs conformance tests across all target languages. External dependencies: The compiler itself has no runtime dependencies; generated code may depend on target platform standard libraries (e.g., GLib for C backend, std::format for C++20, etc.). The C backend uses GLib (GArray, GHashTable, etc.). The compiler hosts require a C++ compiler, C# compiler, Java, or Node.js to build. The test suite requires the respective language runtimes.
ra-supabase is a TypeScript library that integrates react-admin with Supabase. It provides a dataProvider, an authProvider, and OpenAPI-schema-driven UI guessers, allowing developers to generate a complete admin interface from a Supabase project with minimal configuration. The dataProvider translates react-admin CRUD operations into Supabase REST queries, supporting pagination, sorting, filtering, and embedded relationships through a custom `@` syntax. The authProvider wraps Supabase Auth, handling email/password login, OAuth callbacks, password reset, and session management. The guessers fetch the Supabase OpenAPI schema and generate List, Show, Edit, and Create pages, or a full `<AdminGuesser>` scaffold.
This repository is a documentation/runbook, not a software application. It teaches how to secure a Linux server through a long, well-organized markdown guide aimed primarily at Debian-based systems. The content covers SSH key authentication and sshd_config hardening, PAM-based 2FA/MFA and password quality, UFW firewall configuration including Docker interactions, intrusion detection/prevention with fail2ban, CrowdSec, and PSAD, and auditing tools such as AIDE, ClamAV, rkhunter, chkrootkit, logwatch, Lynis, and OSSEC. It also includes a separate kernel sysctl hardening reference table and a short nginx security headers guide. In production, the repository itself does not run anything; its value is the curated collection of copy-paste-ready shell commands, configuration snippets, and operational guidance that a human administrator applies to a server. The architecture is a set of static markdown files with a consistent section pattern (Why, How It Works, Goals, Steps, References), backup-before-edit conventions, and validation steps after changes. The main README is effectively an evolving security runbook with a detailed table of contents, while the auxiliary markdown files serve as standalone reference assets. Recent updates show active maintenance: the guide has been revised for Debian 13 systemd-timesyncd, OpenSSH 9.1 RSA size enforcement, Docker and UFW bypass caveats, and CrowdSec installation. However, some older recommendations remain dated—for example, certain sysctl keys in the hardening table are obsolete or no longer present in modern kernels, and several linked references are from 2018-2019. Because this is a documentation repository rather than executable code, quality assessment focuses on information architecture, practical utility, and reusability rather than software engineering structure.
Pluton is a self-hosted, open-source backup application that wraps restic and rclone to provide scheduled, encrypted backups to a wide variety of cloud and local storage providers. The system is built as a full-stack monorepo with a Node.js/Express backend (TypeScript) and a React frontend (Vite), communicating via REST APIs. It manages backup plans, devices, storage locations, and restore operations through a web dashboard, with support for replication, retention policies, integrity checks, and multi-channel notifications (email, Slack, Discord, push). The architecture follows a layered pattern: controllers handle HTTP requests, services orchestrate business logic, stores encapsulate database access (SQLite via Drizzle ORM), and managers/strategies handle execution of backup, restore, and system operations using restic and rclone as child processes. A job queue with cron scheduling drives automated backups, and event emitters decouple progress tracking and notification dispatch. The frontend provides a rich UI with virtualized file browsers, snapshot viewers, and step-by-step wizards for plan creation and restore. The codebase is well-structured with extensive unit tests, CI/CD pipelines, and cross-platform installers (Docker, Linux AppImage, macOS, Windows).
Jump is a CLI directory navigation tool written in Go that uses fuzzy matching to quickly jump between frequently visited directories. It integrates with major shells (bash, zsh, fish, PowerShell, Nushell) via injected helper functions that hook into directory change events, updating a scoring database stored as JSON files. The single binary dispatches to subcommands for jumping (`j`), managing pins, importing from autojump/z/zoxide, and cleaning the database. The codebase is well-structured with clear separation into config, scoring, fuzzy matching, CLI argument handling, shell integration, and importers. The fuzzy matching algorithm uses Longest Common Subsequence (LCS) on normalized paths, with recency-based scoring. The repository demonstrates strong engineering practices: atomic file writes, embedded shell scripts, comprehensive test coverage, and a modular command pattern. It is production-grade and actively maintained, with recent additions like zoxide binary format import.
react-query-key-manager is a small, dependency-free TypeScript library that provides type-safe, composable, and collision-free query key management for @tanstack/react-query. It exposes two main functions: `key()` wraps a function returning a query key array, augmenting it to support both direct invocation and zero-argument composition calls; `defineQueryKeys()` creates namespaced key collections with recursive nesting, compile-time validation that all functions are wrapped with `key()`, and runtime duplicate-registration detection in development. The library uses advanced TypeScript techniques (const type parameters, mapped types, conditional types) to enforce API usage at build time and to produce precise IntelliSense types. The code is concise (~60 lines of core logic), well-structured, and fully self-contained. It solves a common pain point in large React Query applications—preventing magic string keys, collisions, and poor type safety—through a clever combination of type-level constraints and runtime utilities. The design philosophy emphasizes zero overhead and copy-pasteability, making it easy to vendor into any project. It is framework-agnostic and works with TypeScript 5.0+ and React Query v4/v5. However, the library is in an early stage (version 0.0.2) and lacks a test suite. The registry and keyNames are module-level singletons, which could cause issues in extreme edge cases like multiple library copies, but for typical usage it is solid. Overall, it is a well-crafted utility that delivers on its promises with a clean, type-safe API.
GNews is a Python library and CLI tool that provides a clean, programmatic interface to Google News. It scrapes Google News RSS feeds (or optionally uses the SearchApi backend) to return structured article data including title, description, published date, URL, and publisher. The library supports filtering by language, country, topic, location, site, date range, and period; full article text extraction via trafilatura; real URL resolution via Playwright; proxy configuration for all requests; automatic retry with exponential backoff on HTTP 429; async methods for concurrent queries; and export to JSON/CSV. It is designed as a lightweight, well-tested package with a CLI interface, making it suitable for integration into data pipelines, news monitoring applications, and AI agent workflows. The codebase demonstrates clean separation of concerns with a backend abstraction, utility modules, and custom exception hierarchy.
s6-overlay is a production-grade init system and process supervisor for Docker containers, built on top of the s6 ecosystem (s6, s6-rc, s6-linux-init). It replaces the default container PID 1 with a robust supervision tree that handles zombie reclamation, orderly startup/shutdown, service dependencies, and logging. The architecture is layered: stage0 (s6-linux-init-maker) generates stage1 infrastructure at runtime, stage2 (rc.init) compiles s6-rc service databases and brings up services via s6-rc, supporting both legacy /etc/services.d directories and modern s6-rc source definitions. The system provides utilities like with-contenv (inject container environment), logutil-service (privilege-dropped logging), and with-retries (retry with timeout). It handles edge cases such as read-only root filesystems, non-root USER directives, and Kubernetes world-writable /run configurations. The codebase is predominantly shell and execline scripts, with a Makefile-based build system that cross-compiles all skaware dependencies statically. It is actively maintained, with a clear separation of concerns and extensive documentation derived from the actual code behavior.
This repository is a Rust SDK/framework for building Redis modules, not an end-user application or data/research project. The workspace is organized as a library crate (`redis-module`) plus proc-macro helper crates (`redismodule-rs-macros`, `redismodule-rs-macros-internals`) that wrap the Redis Modules C API. Build code consumes vendored `redismodule.h` through `bindgen`, and the public API provides safe `Context`, `RedisKey`, `RedisString`, `RedisValue`, `RedisModuleIO`, configuration, key cursors, timers, blocking clients, thread-safe contexts, and command/info-handler registration. `redis_module!` and `#[command]` are the main module entry points; the included examples are small runnable modules, and integration tests spawn real `redis-server` processes to exercise them. Architecturally, the crate uses an unsafe FFI layer (`src/raw.rs`) underneath higher-level modules (`src/context/`, `src/key.rs`, `src/configuration.rs`, `src/io.rs`), and uses `linkme::distributed_slice` plus procedural macros to collect command, event, info, and defrag handlers. API-version compatibility is handled by feature flags (`min-redis-compatibility-version-6-0` through `8-0`) with a manual mapping table in `redismodule-rs-macros-internals/src/api_versions.rs`. The vendored C header includes Redis Labs / BigRedis extensions, reflecting production use inside Redis Enterprise modules. External build dependencies include `bindgen`, `cc`, libclang, and a Redis-compatible server for tests. The codebase is well structured for a low-level FFI SDK and contains several genuinely reusable patterns, but it has meaningful caveats: generated bindings are not committed, `bindgen` is pinned to an old version, the manual API-version table must be kept in sync as Redis evolves, and the FFI layer is necessarily large and unsafe. Overall it is an actively maintained, professional-quality SDK with a few deprecated APIs and some fragility around version-gated calls.
This repository is a production-grade Model Context Protocol (MCP) server that bridges AI assistants to Figma. It exposes 100+ MCP tools for reading and manipulating Figma files, variables, components, styles, FigJam boards, Slides, version history, tokens, and accessibility audits. The architecture is dual-mode: a local Node.js server (`src/local.ts`) communicates over stdio to AI clients and via WebSocket to a bundled Figma Desktop Bridge plugin, while a Cloudflare Workers variant (`src/index.ts`) supports cloud sessions with OAuth and a Durable Object WebSocket relay. The Desktop Bridge is the primary data channel, with Figma REST API fallbacks for scenarios where the plugin is unavailable or limited to certain plans. Beyond basic Figma CRUD, the codebase contains substantial engineering investment in design-token synchronization: canonical DTCG-aligned token documents round-trip through parsers and formatters for CSS variables, Tailwind v3/v4, SCSS, TypeScript modules, Style Dictionary, and Tokens Studio. A separate extraction engine (`src/core/extraction/`) mines production codebases for styling conventions and scaffolds design-system packages, while a scoring engine produces weighted design-system health dashboards. These components give the repo a hybrid quality: it is fundamentally an application, but its token pipeline and codebase-analysis subsystems are data-engineering-like assets that could be reused independently. The codebase demonstrates strong engineering practices: strict Zod schemas, consistent tool registration factories, connector abstraction, extensive Jest test coverage, atomic file writes, adaptive response compression, and careful caching/invalidation. However, it also carries meaningful debt: some token parsers are unimplemented stubs, a few files are monolithic (`figma-tools.ts`, `src/local.ts`), local/cloud connector implementations must be kept in sync manually, and some documentation references outdated internal paths. Overall, this is a mature, feature-rich MCP server with several genuinely reusable components for anyone building design-tool pipelines, token bridges, or local process-lifecycle infrastructure.
Polyglot is a Ruby gem that serves as a Jekyll plugin for internationalization (i18n) of static sites. It enables building a site in multiple languages by forking the Jekyll build process per language, patching core Jekyll classes (`Site`, `StaticFile`) to handle language-specific files, and providing Liquid tags for SEO headers (`I18n_Headers`) and URL relativization control (`static_href`). The plugin coordinates documents across languages, supports fallback to the default language, localizes `site.data` via language-specific subdirectories, and generates Netlify-compatible redirects. It is not a standalone application but a library that integrates deeply with Jekyll via hooks and monkey-patching. The repository includes a comprehensive demo site with 18 languages, a full RSpec test suite, CI via CircleCI, and extensive documentation in both README and `ai_docs/`. The codebase is well-structured, with clear separation of concerns (hooks, patches, liquid tags), and demonstrates non-trivial engineering in areas like parallel forking, regex-based URL relativization, and document coordination.
This repository is the official Dropbox Python SDK (v2), providing a comprehensive, typed client for the Dropbox REST API. The core functionality is defined in `dropbox/dropbox_client.py` (concrete client) and `dropbox/base.py` (auto-generated abstract base for all API routes). The SDK includes full OAuth2 support (`dropbox/oauth.py`), robust file upload/download helpers with progress tracking and retry logic (`dropbox/file_transfer.py`), a content hash algorithm for file integrity verification (`dropbox/content_hash.py`), SSL-pinned HTTP sessions (`dropbox/session.py`), and a well-structured exception hierarchy (`dropbox/exceptions.py`). The bulk of the codebase (API data types, route definitions) is auto-generated by the Stone framework from the Dropbox API spec, ensuring consistency with the server endpoints. The repository includes examples for backup/restore, OAuth flows, and file transfer, making it a practical resource for integrating with Dropbox.
The repository provides a command-line tool for computing VMAF (Video Multi-method Assessment Fusion) scores between reference and distorted video streams. It automates preprocessing steps required for accurate VMAF assessment, including deinterlacing, scaling, frame rate adaptation, and temporal synchronization. The tool supports both CPU and GPU-accelerated VMAF computation via libvmaf and libvmaf_cuda, and can process multiple video pairs using glob patterns. The architecture follows a three-layer design: the CLI layer handles argument parsing and output formatting, the VMAF layer orchestrates preprocessing and scoring, and the FFmpeg layer provides low-level wrappers for FFmpeg/FFprobe subprocesses and filterchain management. This separation of concerns makes the FFmpeg wrapper component particularly reusable for other multimedia processing tasks. The tool outputs results in JSON, XML, CSV, or to stdout, and includes features such as automatic sync window search, reverse sync, end-sync option, VMAF model selection (HD and 4K), and CAMBI heatmap generation. It is designed for Linux and macOS, with Docker support for both CPU and GPU environments.
PrestaShop is a full-featured open-source e-commerce platform written in PHP, built on Symfony for the back-office and modern JavaScript/TypeScript for the admin interface. The codebase follows Domain-Driven Design (DDD) with a CQRS pattern, separating commands and queries into dedicated handlers. It provides a complete e-commerce backend including product, order, customer, carrier, tax, and shipping management, along with a powerful grid system, import/export engine, multi-shop and multi-language support, and an OAuth2-secured API. The architecture is a monolith with a modular domain layer, an adapter layer bridging legacy ObjectModel code, and a Symfony bundle layer for controllers, forms, and security. The admin theme uses Vue.js components and a custom grid framework with extensible columns, filters, and actions. Despite active modernization, the codebase retains significant legacy code (jQuery plugins, Smarty templates, deprecated interfaces) and exhibits a mixed architecture that introduces maintenance overhead. The repository is the core of the PrestaShop ecosystem, with a large community and extensive CI/CD pipelines.
This repository implements a DIY smart lock controller for ESP32 hardware, enabling Apple HomeKey NFC authentication, HomeKit integration, and MQTT connectivity for Home Assistant. The architecture is a hybrid embedded system: a C++ backend built on ESP-IDF (FreeRTOS) handles hardware interaction (NFC, GPIO, Ethernet) and protocol stacks (HomeSpan, mbedTLS), while a Svelte 5 frontend hosted on the device's LittleFS provides a web-based configuration and monitoring interface. The system manages configuration persistence in NVS using MessagePack/JSON serialization and streams real-time logs via WebSocket. Engineering quality is high, featuring RAII wrappers for memory safety in C++, template-based configuration management, and a decoupled event-loop architecture. However, the codebase carries significant security debt, explicitly acknowledging the lack of flash encryption and plain-text password storage in configuration. Hardware support is fragmented across ESP32 variants and NFC modules, requiring hardcoded pin presets that limit portability. Despite 52 open issues, the recent commit activity and modern tech stack (ESP-IDF 5.x, Svelte 5) indicate active development.
Perception is a Python library for perceptual image and video hashing, developed by Thorn. It provides a unified interface for multiple hashing algorithms (e.g., pHash, dHash, PDQ, TMK), approximate nearest neighbor search via FAISS with graph-based clustering, and a benchmarking framework for evaluating hasher robustness under various transformations. The library is designed for production use cases like near-duplicate detection, content matching, and CSAM detection via integration with Thorn's Safer service. The codebase demonstrates strong engineering practices: clean abstractions, Cython acceleration, optional dependency management, and extensive test coverage. While primarily an application/library, it includes research-oriented benchmarking pipelines and evaluation datasets, making it a hybrid of production tooling and research infrastructure.
Tabby (formerly Terminus) is a cross-platform terminal emulator built with Electron and Angular 15. It serves as a modern replacement for terminal applications like Windows conhost, PowerShell ISE, PuTTY, macOS Terminal, and iTerm. The application provides integrated SSH, Telnet, and serial clients, local shell support (cmd, PowerShell, WSL, bash, etc.), split panes with drag-and-drop, a fully customizable hotkey system, themes, and an encrypted vault for credentials. The architecture is a monorepo of Angular modules (tabby-core, tabby-terminal, tabby-ssh, etc.) that communicate through dependency injection providers. A plugin system allows third-party packages to extend functionality via well-defined abstract classes (HotkeyProvider, ProfileProvider, TerminalDecorator, etc.). The web variant (tabby-web) provides a browser-based SSH/Telnet client but lags behind the desktop version. The codebase is mature with extensive i18n support, CI/CD pipelines, and community contributions, but shows some drift with Angular 15 being several versions behind current and some legacy naming (terminus- prefix).