atmoz/sftp is a Docker image that provides a production-ready SFTP server built on OpenSSH. At runtime, the container starts sshd with a chroot jail, forcing every user into their own home directory and restricting access to SFTP only. User accounts are provisioned from three sources: command-line arguments, the SFTP_USERS environment variable, and a mounted users.conf file. The entrypoint merges these definitions on first run, generates unique SSH host keys if none are mounted, and optionally executes custom scripts from /etc/sftp.d before launching sshd or passing through arbitrary commands. The core logic lives in two well-crafted Bash scripts. files/create-sftp-user parses compact user specifications (user:pass[:e][:uid[:gid[:dir1,dir2]]]), validates them with POSIX regexes, creates system users with optional UID/GID, sets plain or encrypted passwords, aggregates SSH public keys from .ssh/keys into a deduplicated authorized_keys file, and creates writable subdirectories. files/entrypoint handles configuration merging, first-run initialization, host key generation, and command passthrough. The sshd_config enforces secure defaults: no root login, no TCP forwarding, no X11, and internal-sftp with ChrootDirectory %h. The project includes a solid integration test suite (tests/run) using shunit2 that works with both Docker and Podman, exercising real SFTP sessions, key-based login, directory creation, custom UID/GID, and legacy config paths. CI workflows rebuild images daily to pick up OpenSSH security updates and run ShellCheck plus signature verification. The codebase is small, focused, and well-maintained, with no significant technical debt or security debt. It is a strong example of a purpose-built infrastructure container with clean shell scripting and meaningful test coverage.
Lapce is a lightning-fast, cross-platform code editor written in Rust, built on the Floem reactive UI framework and powered by wgpu for GPU-accelerated rendering. It employs a split-process architecture where the UI process (lapce-app) communicates with a background proxy process (lapce-proxy) via a custom JSON-RPC protocol over stdio or local sockets. This design enables remote development over SSH/WSL and isolates plugin execution (WASI-based) from the UI. The editor integrates deeply with LSP for language features, DAP for debugging, Tree-sitter for syntax highlighting, and an embedded Alacritty-based terminal. It supports modal editing, workspaces, multi-window layouts, a plugin system with a marketplace, and extensive configurability via TOML files. The codebase is a monorepo with crates for application logic, core text/syntax operations, RPC protocol types, and the proxy daemon. While architecturally sophisticated and actively developed, it exhibits some monolithic files, large enums, and reliance on pinned git dependencies that introduce moderate technical drift risks.
This repository is a collection of Claude Code skills and Python scripts that automate daily paper recommendation and note-taking for researchers. It fetches papers from HuggingFace Daily Papers, HuggingFace Trending, and arXiv API, scores them against user-defined keywords, enriches metadata (authors, affiliations, figures, method names), and generates a tiered daily recommendation markdown file (must-read, worth reading, skip). For must-read papers, it invokes a paper-reader skill that produces detailed structured notes with figures, formulas, tables, and concept wiki entries, all saved into an Obsidian vault. It also fetches GitHub Trending repositories and writes notes. The system includes a web viewer (FastAPI + vanilla JS) for browsing the vault content, with full-text search, wikilink resolution, and a Claude chat interface. The architecture is a three-step pipeline (fetch, review, notes) orchestrated by Claude Code skills, with Python scripts handling data fetching, scoring, enrichment, and file management. The codebase demonstrates solid engineering: async HTTP with fallback chains, robust HTML parsing, heuristic text extraction, and clean modular design. It is primarily an application (a set of tools) rather than a data research project, though it involves significant data processing.
This is the official Moodle mobile app, a large hybrid application built with Angular 20, Ionic 8, and Cordova 13. It is a client for the Moodle LMS and talks to Moodle sites through Moodle web services. The application uses an offline-first architecture with per-site SQLite schemas, sync/cron services, prefetch handlers, and a file pool, allowing users to browse courses, participate in activities (assignments, quizzes, forums, SCORM, H5P, etc.), receive push notifications, and manage files while disconnected. The primary entry points are `src/main.ts`, the Angular root component `src/app/app.component.ts`, and lazy-loaded modules under `src/core/features/` and `src/addons/`. The app includes a custom Cordova plugin for secure storage, diagnostics, and install referrer tracking, plus a Behat plugin for acceptance testing. Although the repo is dominated by application code, it contains some data-adjacent artifacts: offline database schemas, xAPI statement support, and language-pack generation scripts; these are not research pipelines and are best understood as application infrastructure.
ASPECT (Advanced Solver for Problems in Earth's ConvecTion) is a massively parallel, finite-element geodynamics simulation code built on the deal.II library. It solves the Stokes and advection-diffusion equations for mantle convection, lithosphere dynamics, melt migration, and related tectonic processes. The code features a highly modular plugin architecture with registration macros for material models, heating models, boundary conditions, postprocessors, mesh refinement, particle tracking, and more. It includes an extensive benchmark suite for code verification and numerous cookbooks demonstrating real geodynamic applications. The repository also bundles the Geodynamic World Builder (contrib/world_builder), a standalone library for constructing initial temperature, composition, and velocity fields from structured input files. ASPECT is actively developed with continuous integration, Docker support, and coupling to external tools like Landlab and FastScape for surface processes.
This repository is the official Ghost Starter Theme, a foundation for building custom Ghost CMS themes. It provides a complete set of Handlebars templates (default.hbs, index.hbs, post.hbs, etc.), modular CSS components (buttons, forms, global reset), and JavaScript modules (mobile menu toggle, infinite scroll) that are compiled and optimized via Rollup and PostCSS. The theme is designed to be extended and includes CI/CD workflows for testing and deployment. It is not a standalone application but a theme package that runs within the Ghost CMS environment (>=5.0.0). The codebase demonstrates modern front-end tooling with ESM, CSS custom properties, and responsive image handling. While the theme itself is tightly coupled to Ghost's template engine, several components (CSS patterns, infinite scroll, menu toggle) are self-contained and could be extracted for use in other projects.
This repository contains Pound, a Nintendo Switch emulator focused on emulating Switch 1 and 2 hardware. The emulator features a modular architecture with CPU emulation handled by the Ballistic ARM recompiler for performance, GPU emulation translating Switch graphics commands to host APIs (Vulkan, OpenGL, DirectX, Metal), and SDL-based cross-platform windowing, input, and audio systems. Dear ImGui integration provides debugging and configuration interfaces. The codebase demonstrates careful separation of concerns, with distinct subsystems for memory management, CPU state, platform abstraction, and hardware emulation. Notable engineering practices include the clean interface boundary with the Ballistic recompiler, memory allocation abstraction via a host allocator interface, and platform detection utilities. While the project shows active development and solid engineering, it faces typical emulator challenges including platform-specific maintenance burdens and dependency on external shader translation tools.
This repository provides deployment and configuration artifacts for Mend Renovate Self-Hosted, a commercial offering that wraps the open-source Renovate dependency update tool. It contains Helm charts for both Community and Enterprise editions, Docker Compose examples, environment variable references, TLS configuration templates, and OpenAPI specifications for the management API. The actual application code (server, worker, web UI) is distributed as pre-built Docker images and is not present in this repo. The system operates as a distributed job queue: a server schedules and enqueues dependency update jobs, workers execute Renovate CLI runs, and an optional web UI provides administrative dashboards. Enterprise features include worker queue isolation, Kafka event notifications, RBAC, and enhanced reporting (LibYears, pull request stats). The repository is well-documented with clear setup guides for GitHub, GitLab, and Bitbucket Data Center, and includes CI/CD workflows for linting and releasing Helm charts. While the repo contains no application source code, its deployment artifacts are professionally structured and follow best practices for extensibility (e.g., extra manifests, worker pool templates).
OpenClash is an OpenWrt/LuCI application that turns a router's admin interface into a full Clash/Mihomo proxy management system. The production code is mostly Lua CBI/controller modules, view templates with embedded JavaScript, and shell/Ruby orchestration scripts. It manages subscription downloads, YAML config generation and overwrite, core binary updates, GeoIP/GeoSite/China-route database updates, DNS/firewall integration, streaming-unlock probe and selection, and optional OIX managed-service integration. It also bundles the MetaCubeXD and zashboard single-page dashboards for live proxy monitoring and connection inspection. Architecturally, the project is an OpenWrt package: UCI configuration, an init.d service, and watchdog/procd lifecycle management. The LuCI controller exposes around 80 JSON/AJAX actions and uses low-level nixio fork/poll/pipe helpers for streaming subprocess output. The backend repeatedly combines shell scripts with Ruby-based YAML parsing and mutation to handle Clash configuration. External dependencies are significant: GitHub releases/CDNs for core and GEO data, subconverter services, the OIX API, and several IP-info services. Hardcoded URLs, vendored minified dashboard bundles, and multi-language shell/Ruby/Lua/C tooling are the main technical-drift risks. This is not a data-research repository; the data handled is operational proxy/node/routing state rather than analyzable datasets. No automated test suite is apparent in the tree; quality comes from defensive shell patterns (flock locks, ETag caching, retry loops) and feature depth rather than automated verification. The most reusable pieces are YAML.rb's merge/encryption layer, the server_url share-link parser widget, and the controller's streaming subprocess helpers.
This repository is a mature, well-structured JavaScript library that dynamically generates HTML forms from JSON Schema definitions. It is a client-side library that can be used as a standalone script or npm package. The core architecture is built on an abstract base class (`AbstractEditor`) with a rich plugin system for editors (string, number, array, object, etc.), themes (Bootstrap 3/4/5, Tailwind, Spectre, etc.), icon libraries, and template engines. It includes a full JSON Schema validator with support for draft-04, 07, and 2020-12 keywords, plus custom validators. The codebase demonstrates strong engineering practices: event-driven communication, extensible resolver patterns, and a modular design that separates concerns. However, the project is explicitly in maintenance mode, with active development moved to a fork (Jedison). This means new features are not expected, but critical bug fixes and security patches are still accepted. The codebase shows some technical drift: several third-party integrations (e.g., SimpleMDE, SignaturePad v1) are outdated, some themes (Foundation 3, Bootstrap 2) are legacy, and the code uses ES5 patterns. The test suite is extensive, with both unit tests (Jasmine) and end-to-end tests (CodeceptJS) covering many edge cases and real-world issues. Overall, it is a high-quality library for its domain, but its maintenance mode status limits its future viability for new projects.
Iodine is a high-performance Ruby web server and application framework built on the facil.io C library. It provides a Rack/NeoRack compatible server with WebSocket, Server-Sent Events, Pub/Sub, static file serving, TLS termination, and response compression. The framework also includes a rich set of utilities: modern cryptographic primitives (ChaCha20-Poly1305, Ed25519, X25519, post-quantum X25519MLKEM768, Argon2, etc.), JSON parsing, Mustache templating, compression (Deflate, Gzip, Brotli), and a RESP3 Redis client for scalable Pub/Sub. Architecture: Multi-process master-worker model. The master process monitors workers and handles Pub/Sub message routing. Each worker runs a C reactor thread for I/O and a Ruby thread pool for application code, achieving GVL-free concurrency. Configuration is via CLI flags, environment variables, or config.ru/config.nru files. Supports hot restarts (SIGUSR1) and cluster mode (multi-process with fork). Key entry points: exe/iodine (main executable), lib/iodine.rb (Ruby-side boot), and the C extension ext/iodine/iodine.c. The Iodine::Connection class handles HTTP/WebSocket/SSE/TCP connections. Iodine::Listener manages server sockets and URL routing. Iodine::PubSub provides pluggable engines (LOCAL, CLUSTER, RESP3) with history replay. Iodine::Base::Crypto and Iodine::Base::Compression offer self-contained utility modules. External dependencies: facil.io C library (bundled), optional OpenSSL for TLS, optional Brotli for compression. The gem is self-contained but requires a C compiler. The codebase includes a comprehensive test suite and benchmarks. Caveats: embedded TLS 1.3 is unaudited, Windows support is experimental and single-process only, and HTTP/2 is not supported. The project is actively maintained with recent commits and support for Ruby 3.2–4.0.
This is an R package (`parameters`) from the easystats ecosystem that provides a unified interface for extracting, formatting, and comparing parameters from a vast array of statistical models (lm, glmmTMB, brms, lme4, lavaan, fixest, etc.). The package functions as a model-parameter reporting engine: it takes a fitted model object and returns a tidy data frame with coefficients, standard errors, confidence intervals, p-values, and effect sizes, supporting various inference methods (Wald, profile, bootstrap, Kenward-Roger, Satterthwaite). Beyond basic extraction, it offers standardization, bootstrapping, equivalence testing, p-value functions, dominance analysis, and data reduction (PCA, EFA, clustering). The architecture relies heavily on S3 generic dispatch (e.g., `model_parameters.lm`, `model_parameters.glmmTMB`) and integrates with the easystats stack (`insight` for model introspection, `bayestestR` for Bayesian indices, `datawizard` for data manipulation). Output can be formatted as plain text, markdown, or HTML, making it suitable for both interactive use and automated reporting. The package is actively maintained with extensive test coverage and continuous integration.
Syntheseus is a Python package for retrosynthetic planning that provides a unified framework for integrating various single-step reaction models with search algorithms to find synthetic routes from target molecules to available starting materials. The package features a plugin architecture that allows users to plug in different reaction models (such as Chemformer, GLN, LocalRetro, etc.) and search algorithms (like MCTS, Retro*, Breadth-First, etc.) through well-defined abstract base classes. It includes command-line interfaces for running end-to-end searches and evaluating single-step model performance, along with tools for route analysis and visualization. The architecture emphasizes separation of concerns: the interface module defines core abstractions (molecule, reaction, bag, and models), the reaction_prediction module handles model loading and inference, and the search module implements the search algorithms and graph representations. This design enables easy extension and experimentation with new models and algorithms. The package is actively used in academic research and has been applied in recent publications for benchmarking retrosynthesis approaches.
Yave is a C++20 Vulkan-based real-time graphics engine paired with a custom ImGui-driven editor and a self-contained core utility library named `y`. The repository is structured as three layers: `y` provides reusable containers, math, concurrency, IO, serialization, and a test framework; `yave` implements the engine itself (Vulkan device/window management, frame graph, render passes, ECS, asset pipeline, physics, animation, and scripting); and `editor` is a full 3D scene editor application with workspaces, widgets, gizmos, importers, thumbnails, and undo/redo. The renderer supports deferred PBR, cascaded shadow maps, TAA, bloom, SSAO/RTAO, RTGI, atmosphere scattering, and tone mapping, and it runs through a declarative frame graph with automatic resource pooling and barrier insertion. The editor is not a separate toy: it provides asset browsing, glTF/image import, material editing, scene outliner, inspector, file system views, performance metrics, GPU profiling, and RenderDoc integration. The engine uses a modern ECS with component groups, async asset pointers, and a serialization framework that supports schema evolution. The `y` library is particularly notable for its clean, high-performance primitives: SSO strings, flat hash maps with SIMD probing, sparse component sets, dependency-aware job system, and a forward/backward-compatible binary serialization layer. Externally, it depends on Vulkan, VMA, Volk, Dear ImGui, JoltPhysics, LuaJIT, tinygltf, stb, Tracy, and spirv_reflect, mostly vendored. While the project is described by its author as a learning/pet engine, the code is generally well-structured and professionally organized. However, it is a single-author codebase with many `Y_TODO` markers, some stubbed platform paths, global device singletons, and an explicit compiler-dependent serialization format. Tests exist mainly for the `y` core containers and math, not for the engine or editor. The repository is active and uses current C++/Vulkan practices, but should be treated as an evolving research-quality engine, not a stable library.
OrientDB is a multi-model NoSQL database management system supporting document, graph, object, and relational data models within a single engine. It provides ACID transactions, a SQL-like query language, distributed clustering with automatic sharding and replication, full-text and spatial indexing via Lucene, and a Gremlin graph traversal API. The system is implemented in Java and organized into modular components: a core storage engine with pluggable index structures (SB-Tree, hash, Lucene), a binary client-server protocol, an HTTP REST API, and a web-based administration studio (AngularJS). It includes enterprise features such as backup/restore, metrics monitoring, and security auditing. The architecture follows a plugin-based server model, allowing extensions for authentication, indexing, and custom commands. External dependencies include Dropwizard Metrics, Lucene, Gremlin/TinkerPop, and various compression libraries.
This repository implements a complete embedded IoT system for automated meter reading (water, gas, electricity) using an ESP32-CAM with on-device TensorFlow Lite inference. The firmware captures images, performs alignment and ROI extraction, runs digit and analog pointer recognition via quantized TFLite models, applies post-processing (consistency checks, rate limiting, decimal shift), and publishes readings via MQTT, InfluxDB (v1/v2), Webhook, or a built-in REST API. The architecture follows a modular flow-control pattern with separate components for camera control, image processing, neural network inference, configuration, logging, and output protocols. A full-featured web interface provides setup wizards, live data graphs, OTA updates, and file management. The system is designed for low-power edge deployment on ESP32 with PSRAM and SD card storage.
FlexGet is a rule-based media download automation tool written in Python. It manages the acquisition of TV series, movies, and other content from RSS feeds, torrent sites, Usenet indexers, and custom sources. The system uses a plugin architecture where each feature (input, filter, output, notifier, metadata lookup) is a plugin registered via an event system. Tasks are defined in YAML configuration files and executed through a pipeline of phases (input, metainfo, filter, modify, output). It runs as a daemon with a built-in scheduler (APScheduler), provides a REST API (Flask-RESTx) for remote management, and includes both a legacy AngularJS web UI and a modern React-based UI. The codebase is extensive with over 100 plugins, SQLAlchemy-based persistence, and a comprehensive test suite. While primarily an application, it incorporates data engineering patterns such as caching, rate limiting, and metadata enrichment from external APIs (TMDB, Trakt, IMDB, TVDB).
SigNoz is a full-stack open-source observability platform that ingests OpenTelemetry data (traces, metrics, logs), stores it in ClickHouse, and provides a rich web UI for querying, dashboards, alerts, and infrastructure monitoring. The backend is written in Go with a modular architecture using factory/provider patterns, SQL migrations, and OpenFGA-based authorization. The frontend is a React/TypeScript SPA with Zustand state management, react-query, uPlot charts, and a comprehensive query builder supporting PromQL, ClickHouse SQL, and builder queries. The enterprise edition adds anomaly detection, RBAC, licensing, and usage metering. The codebase is actively maintained with extensive testing (unit, integration, e2e) and CI/CD, though some legacy API versions and deprecated clients indicate ongoing migration.
This is an Android TV application that serves as a client for media servers (primarily Jellyfin). It implements a Clean Architecture with clear separation between Data, Domain, and Presentation layers, using Jetpack Compose for the UI, Hilt for dependency injection, and Kotlin Coroutines/Flow for asynchronous operations. The application provides a TV-optimized interface for browsing media libraries, playing content with support for multiple players (ExoPlayer and MPV), handling subtitles/audio tracks/video quality, and managing user preferences. Key features include offline caching, background synchronization, advanced video format support (HDR, Dolby Vision), and a polished user experience with animations and focus handling for TV remotes.
This repository provides `claude-monitor`, a privacy-first CLI application for real-time monitoring of Claude Code usage. It reads local JSONL session logs, computes token consumption, costs, and burn rates, and displays them via a Rich-based terminal UI. The tool supports multiple subscription plans (Pro, Max5, Max20, Custom), integrates with Claude Code's official rate limits via statusline capture, and offers an opt-in persistent usage warehouse for historical analysis. It is distributed as a PyPI package with command aliases `cmonitor` and `ccm`. The architecture is modular, with separate packages for CLI, core logic, data ingestion/analysis, monitoring, output formatting, terminal management, UI components, and utilities. Key entry points include the CLI main module (`cli/main.py`), snapshot builder (`output/snapshots.py`), and monitoring orchestrator (`monitoring/orchestrator.py`). The application is well-tested with over 700 tests covering snapshot, trust-layer, warehouse, UI, timezone, and CLI paths. While primarily an application, it incorporates data engineering patterns such as sessionization, percentile-based limit estimation, and a versioned JSON warehouse. The codebase demonstrates strong craftsmanship with reusable components like the P90Calculator, PricingCalculator, TimezoneHandler, and UsageWarehouse. However, it has some technical drift risks due to hardcoded pricing rates, dependency on Claude Code's internal log format, and experimental API features that may change.