This repository is a tutorial sample blog application built with Spring Boot and Kotlin. It demonstrates how to combine Spring Boot with Kotlin idioms such as data classes, extension functions, null safety, and the Kotlin-specific Spring Boot bootstrap. The application provides both an HTML frontend (using Mustache templates) and a REST API for articles and users, backed by an in-memory H2 database via Spring Data JDBC. It includes integration tests using RestTestClient and unit tests with Mockk and SpringMockk. The code is clean, well-structured, and serves as an official reference for building Spring Boot applications with Kotlin.
This is a comprehensive test automation framework for 1C:Enterprise 8.3 managed applications, named 'Tester'. It provides a full suite of tools for creating, managing, executing, and reporting on UI and business logic test scenarios. The repository contains three main integrated components: (1) a native C++ add-in (addon/) that exposes low-level capabilities like screenshot capture, regex, file watching, metadata parsing, and a Model Context Protocol (MCP) server for AI agent integration; (2) a 1C:Enterprise configuration (tester/) with catalogs, documents, common modules, and forms implementing scenario lifecycle management, execution engine with debugging, job scheduling, error logging, and report generation; and (3) a VS Code extension (addon.vscode/) for editing scenarios with syntax highlighting, code completion, and direct test execution. The system supports distributed execution via agent computers, file system synchronization with external editors (EDT, VS Code), version control through git integration, and role-based access control. Notable patterns include a bilingual API (English/Russian method aliases), a fluent assertion library, a custom JSON diff engine for UI state comparison, and an XML log transpiler that converts recorded user actions into executable scripts. Documentation is extensive, including a separate wiki site built with MkDocs. The repository is actively maintained with frequent releases, though it shows medium technical drift due to some outdated dependencies in the VS Code extension and use of platform-specific workarounds.
msldap is a Python library and CLI tool for interacting with Microsoft Active Directory via LDAP. It provides both a low-level async connection (MSLDAPClientConnection) and a high-level client (MSLDAPClient) with convenience methods for enumerating users, computers, groups, GPOs, trusts, and more. The library supports multiple authentication methods (NTLM, Kerberos, simple, SSPI), LDAPS, SOCKS proxy, and includes an interactive console client (msldap) and a BloodHound collector (msldap-bloodhound). It also features ADCS vulnerability scanning, shadow credentials, LAPS extraction, DNS record manipulation, and an LDAP relay server. The codebase is well-organized with a modular architecture, extensive test suite (offline and live interop tests), and several reusable components such as a custom ASN.1 packetizer, LDAP filter parser, and binary structure parser. However, it has some known bugs (7 registered in known_failures.yml), vendored dependencies (asciitree, aiocmd) that may drift from upstream, and a few code quality issues (typos, dead code). Overall, it is a solid, feature-rich tool for AD security assessments.
react-dropdown-tree-select is a React component library that provides a dropdown interface for selecting items from hierarchical tree data. The component supports multiple selection modes (multi-select, simple select, radio select, and hierarchical), displays selected items as tags/pills, includes search functionality with progressive filtering and debouncing, offers keyboard navigation, and implements accessibility features through ARIA attributes. The architecture centers around a DropdownTreeSelect component that uses a TreeManager to handle tree state and operations, with supporting components for rendering trees, nodes, tags, and controls. Performance optimizations include virtualized rendering via react-infinite-scroll-component, search debouncing, and progressive filtering that reduces search scope with each keystroke.
MailChecker is a cross-language email validation library that detects emails from temporary/disposable email providers, distributed as first-class packages for Node.js, PHP, Python, Ruby, Rust, Go, Elixir, Clojure, browser JavaScript, and Java. All platforms share one curated plain-text blacklist (list.txt) of ~55,000 disposable domains and expose a normalized API — isValid/valid?/is_valid, blacklist(), and addCustomDomains. Each implementation combines a strict RFC-style regex format check with suffix-based blacklist matching, so subdomains of known disposable domains (e.g. [email protected]) are also rejected. The npm package is deliberately dependency-free, using only a Set and a single anchored regex at runtime. The defining architectural pattern is template-driven code generation: lib/clean.js deduplicates and validates list.txt against the public suffix list, lib/loader.js reads it, and lib/generator.js renders *.tmpl.* files into final platform sources, meaning a single PR that edits list.txt propagates to every language distribution after a build. Tests exist for all major platforms and CI runs them in Docker for Node, PHP, Python, Ruby, Rust, Go, and Elixir. Maintenance is genuinely active, with v6.0.21 released in July 2026 and continuous community PRs adding/removing domains. However, the toolchain lags: test images pin EOL runtimes (Python 2.7/3.6, Ruby 2.2, Go 1.13), the abandoned mu2 template engine powers the generator, the Clojure test is disabled because the emitted source is too large for the compiler, and the Java platform loads list.txt from classpath resources but no such resource file is committed, making that platform effectively non-functional as distributed. The core Node, PHP, Python, Ruby, Go, and Rust implementations are solid, idiomatic, and well-tested.
This repository provides a Python CLI tool and Makefile pipeline to scrape all essays from Paul Graham's website (paulgraham.com), convert them to Markdown, and produce an EPUB ebook. The core logic resides in a single script (`graham.py`) that uses `requests`, `BeautifulSoup`, `html2text`, and `htmldate` to download, parse, and date-stamp each essay. A `Makefile` orchestrates the full build: creating a virtual environment, fetching essays, merging them with `pandoc`, and generating the final EPUB with a custom CSS and an iBooks dark-mode patch. The CI workflow (GitHub Actions) runs daily, detects new essays by comparing article counts, and automatically creates a release with the updated EPUB and metadata CSV. The architecture is straightforward—no web server, database, or tests—but the pipeline is robust and well-documented for its single purpose. While the scraper is tightly coupled to Paul Graham's site structure, several components (the iBooks patcher, the footnote conversion function, and the EPUB stylesheet) are cleanly isolated and reusable in other EPUB generation projects.
This repository implements a web service called nightly.link that enables permanent, shareable download URLs for GitHub Actions build artifacts without requiring users to authenticate with GitHub. It acts as a proxy that redirects to time-limited download URLs provided by the GitHub API, using a GitHub App installation token for authorization. The architecture is a single Crystal web server using the Retour HTTP router, ECR templating, and SQLite for persisting repository-to-installation mappings. Key functionality includes resolving workflow files to their latest successful run's artifacts, direct artifact download by ID, and job log downloads. The codebase demonstrates clean separation of concerns, robust error handling, and a caching layer to reduce API calls.
musikcube is a cross-platform, terminal-based music player and streaming server written in C++. It consists of a core library (`musikcore`) with a plugin-based architecture for decoders, encoders, audio outputs, DSP, and data streams. The project includes three distinct front-ends: a terminal UI (`musikcube`) built on a custom curses++ framework, a native Windows UI (`musikwin`) using a custom Win32 wrapper, and an Android remote client (`musikdroid`) written in Kotlin. The server plugin enables remote control and audio streaming via WebSocket and HTTP. The core manages a SQLite-backed music library with indexing, metadata extraction (via TagLib), and playlist management. Audio playback supports gapless and crossfade transitions, visualizers, and an equalizer. The system is designed for extensibility through a well-defined SDK interface set, allowing third-party plugins for decoders, outputs, and DSP. The codebase is mature (copyright 2004-2023) and shows signs of organic growth, with heavy vendored third-party dependencies and platform-specific code. While not architecturally pristine, it demonstrates solid engineering, a clean plugin API, and reusable UI frameworks.
This repository is the complete open-source hardware and software stack for the Roboto Origin bipedal robot, formerly known as Atom01. It is a hybrid monorepo covering mechanical design (CAD files, 3D printing, BOMs), electronics (PCB designs, firmware for a USB2CAN board), low-level ROS2 control (motor drivers, IMU, camera, inference), simulation and reinforcement learning training (roboparty_train with Isaac Sim/MuJoCo and PPO/AMP algorithms), navigation (LiDAR localization, UWB, path planning), and XR teleoperation. The repository is organized into multiple modules, each with its own build system (CMake, Zephyr, Python). The dominant character is an application (a robot system), but it includes a substantial data_research component in the training module where RL policies are trained using motion capture data. The codebase is well-structured, actively maintained, and provides a complete recipe for building and deploying a humanoid robot from scratch.
This repository is a ComfyUI custom node pack that extends the standard ControlNet functionality with advanced scheduling, weighting, and masking capabilities. It provides nodes for timestep and latent keyframes, custom weight curves, attention masks, effect masks, and sliding context windows for video generation (AnimateDiff integration). The system supports multiple control types: ControlNet, T2IAdapter, ControlLoRA, ControlLLLite, SparseCtrl, SVD-ControlNet, Reference, ControlNet++, and CtrLoRA. It also replicates features from Auto1111 like 'My prompt is more important' via soft weights and uncond_multiplier. The architecture is modular, with separate files for each control family (control.py, control_reference.py, control_ctrlora.py, etc.), a shared utilities module (utils.py) providing base classes like AdvancedControlBase and ControlWeights, and a node registration layer (nodes.py, nodes_main.py, etc.). The system integrates deeply with ComfyUI's internal APIs (comfy.controlnet, comfy.model_patcher, comfy.hooks) and uses monkey-patching to inject advanced behavior into standard control objects. A custom inter-node communication protocol (DinkLink) enables coordination with AnimateDiff-Evolved. Key entry points are the node classes registered in __init__.py and nodes.py, which are loaded by ComfyUI's extension system. The primary data flow involves loading a control model, optionally converting it to an advanced version, applying timestep/latent keyframes and weights, and then applying the control during sampling with optional reference injection or sliding context. The system is actively maintained with recent commits, CI publishing, and example workflows demonstrating advanced features like Qwen Image Inpainting and Anima LLLite v2.
Redka is a Redis-compatible data store implemented in Go, using SQLite or PostgreSQL as the storage backend. It reimplements core Redis data structures (strings, lists, sets, hashes, sorted sets) with full TTL support, key scanning, and set/sorted-set aggregation operations. The system can be deployed either as an embedded Go library (via the `redka` module) or as a standalone RESP-compatible server (single binary or Docker image). Architecture follows a clean layered design: a top-level `DB` struct provides transactional access to per-type repositories (e.g., `ZSet()`, `Hash()`), which in turn use a dialect abstraction layer (`sqlx`) to generate SQLite- or PostgreSQL-specific queries. The RESP server is built on `tidwall/redcon` with a command dispatch pattern and a reusable parser combinator framework for argument parsing. While feature-complete for core Redis operations, the project is explicitly in maintenance mode—no new features are planned, and documentation notes incomplete command coverage (e.g., blocking operations, some sorted set commands). The codebase is well-structured with extensive test coverage, but Postgres support shows signs of drift (many queries aliased to SQLite) and the command dispatch switch has grown large.
This repository provides a Cockpit plugin for managing file-sharing services on a Linux server, including Samba (SMB/CIFS), NFS, iSCSI, and multiple S3-compatible object storage backends (MinIO, Ceph RGW, Garage, RustFS). It is built as a Vue 3 + TypeScript single-page application that uses Cockpit's IPC API to execute system commands and read/write configuration files. The UI is organized into tabs, one per service, with each tab offering full CRUD operations for shares, exports, targets, LUNs, buckets, and access policies. The codebase demonstrates a well-architected frontend with a clean separation of concerns: common reusable composables and UI components, service-specific managers that encapsulate CLI interactions, and a backend adapter pattern for S3 providers. A notable refactoring from an older Vue 2/Options API version to the current Composition API + TypeScript is evident from the presence of a deprecated `file-sharing-old/` directory, but the active code is modern and maintainable. While the plugin is tightly coupled to the Cockpit framework and expects specific system tools, the internal patterns—such as the abstract `BucketBackend` interface, `ShareManagerMixin`, `ISCSIDriver` abstraction, and promise-based modal prompt—are sufficiently isolated to be reused in other system administration or configuration management tools.
This repository is a cookbook of runnable examples for the OpenClaw SDK. It contains two layers: small one-concept recipes (e.g., run-an-agent, stream-events, cancel-a-run) and standalone starter apps (quickstart Node app, coding-agent CLI, agent-workbench React app, run-board React dashboard). The code demonstrates SDK workflows such as starting runs, streaming normalized events, cancelling work, reusing sessions, checking model status, and testing with an in-memory transport. The architecture is modular: recipes are self-contained TypeScript files with shared configuration helpers, and SDK examples are independent packages that can be copied out and adapted. The repository includes comprehensive tests, CI checks, and a workspace SDK shim for local validation without a live Gateway. It is actively maintained with modern dependencies (TypeScript 7, Node 22, pnpm 10.34.5) and follows strict formatting and linting rules.
WanAndroid is a polished, feature-rich Android client for the WanAndroid platform (wanandroid.com), a Chinese community for Android developers. The application provides comprehensive browsing of articles, projects, WeChat articles, knowledge trees, navigation, Q&A, book tutorials, and daily news aggregation from multiple Chinese sources. It implements a classic MVP architecture with a modular project structure (app, basic/core, basic/ui, basic/utils, basic/l10n, component/ad). Key entry points include SplashActivity and MainActivity (hosting a bottom-tab fragment container). The system heavily leverages OkHttp/RxHttp for network requests to the WanAndroid REST API, DiskLruCache for offline caching, Room for local persistence (read-later and read-history), and EventBus for cross-component events. Beyond vanilla browsing, it features a custom WebView subsystem (WebInstance, WebContainer) with resource interception, offline HTML/ CSS caching, a reading mode using readability4j and Jsoup, and JavaScript injection for image clicks. It also includes text-to-speech (TTS) via Android TTS engine with AI-powered summarization, biometric quick login, QR code scanning, card/article sharing, a coin/ranking gamification system, and in-app updates. External dependencies include Google AdMob for ads, optional AI provider APIs (e.g., DeepSeek), and the WanAndroid server endpoints. The codebase is a mix of Java and Kotlin, with several reusable custom UI components like BottomDrawerLayout, ImagePreviewView, CollectView, and custom pull-to-refresh headers with Chinese poetry.
node-java is a native Node.js addon that provides a bidirectional bridge between Node.js and the Java Virtual Machine (JVM). It allows JavaScript code to instantiate Java classes, call static and instance methods, get/set fields, create arrays, handle Java exceptions, and create dynamic proxies for Java interfaces. The architecture comprises three layers: C++ native bindings (using NAN and JNI), Java helper classes for reflection and method invocation, and a JavaScript API exposed as a single import. The system manages JVM lifecycle, async method dispatch via libuv, and complex type conversions (including primitives, arrays, varargs, and Unicode strings). It is widely used (1890 stars) with active maintenance and cross-platform support (Linux, macOS, Windows, ARM).
AutoRest is a production-grade code generation tool that transforms OpenAPI (Swagger) specifications into client SDKs for multiple programming languages, including C#, Java, Python, Ruby, Go, and Node.js. It is the primary tool used by Azure to generate SDKs for Azure services, but it can be used for any REST API. The system ingests OpenAPI 2.0/3.0 documents, validates them, and processes them through a plugin-based pipeline to produce language-specific client libraries. The architecture is built around a directed acyclic graph of pipeline plugins, each responsible for a specific transformation stage (modeling, flattening, naming, emitting). The core engine orchestrates the pipeline, manages configuration loading and merging, and handles extension lifecycle. A virtual file system with source mapping tracks the provenance of generated code back to original spec positions, enabling accurate error reporting and blame tracking. Key entry points include the CLI application at packages/apps/autorest/src/app.ts, the core processing engine at packages/extensions/core/src/lib/autorest-core.ts, and the modelerfour extension that converts OpenAPI to an intermediate code model. The system also includes an experimental path to convert OpenAPI to TypeSpec via the openapi-to-typespec extension. External dependencies include npm for extension management and runtime environments (Java, Python, .NET) for generated code validation. The data flow begins with loading and parsing OpenAPI specs, followed by validation, conversion to a language-agnostic code model, and finally emission of language-specific SDK code. The pipeline supports caching, configuration merging with interpolation, and directive-based customization (e.g., removing operations, renaming components). The codebase is a large monorepo with many interdependent packages, showing signs of long-term evolution and some technical debt.
void-mklive is the official build system used to produce Void Linux live ISOs, rootfs tarballs, platform-specific disk images, network boot artifacts, WSL images, and cloud/Vagrant images. It is not a service or library; it is a set of root-requiring bash/sh CLI tools wired together by a Makefile and GitHub Actions workflows. The core pipeline runs from mkrootfs.sh (generic ROOTFS for many architectures via xbps), through mkplatformfs.sh (platform specialization such as Raspberry Pi, Pinebook Pro, GCP, Asahi), to mkimage.sh (dd-able disk images), while mklive.sh/mkiso.sh build hybrid/EFI live ISOs with squashfs, dracut initramfs, GRUB, and syslinux. mknet.sh produces PXE boot tarballs. installer.sh provides an interactive dialog-based installer, and the dracut/autoinstaller module provides a configurable unattended installer that runs directly from the initramfs. Architecturally, most scripts source lib.sh, which encapsulates the hard parts of cross-architecture rootfs work: native versus foreign architecture detection, idempotent QEMU binfmt registration, pseudofs bind-mount setup/teardown, and target-aware command execution. The repository also ships dracut modules for live media behavior, Packer HCL templates for Vagrant and cloud images, and platform descriptor scripts. External dependencies include the xbps package manager and Void repositories, dracut, squashfs-tools, xorriso, syslinux, GRUB, qemu-user-static, and standard Linux block device utilities. The code is maintained and generally well-commented, with careful cleanup and idempotency in the shared chroot helpers. Its main weaknesses are some duplicated and legacy Packer definitions (hardcoded 20240314 ISO URLs), a monolithic installer, and no automated test suite; however, for a distribution image build tool this is solid, professional shell code.
This repository is the Tonhub Wallet, a non‑custodial mobile cryptocurrency wallet for the TON blockchain with additional Solana support. It is a full‑featured wallet that supports multi‑account management, token transfers (jettons), staking (liquid staking, native pools), hardware wallet integration (Ledger), a dApp browser using TonConnect v2, and financial products such as the Holders card program and Changelly exchange. The application also includes an AI chat assistant for transaction markup and operations, push notifications via Firebase, and deep‑link navigation for seamless URL handling. Built using React Native and Expo, the codebase is structured around a fragment‑based screen architecture, with custom hooks and React Query for data fetching, Recoil for state management, and a centralized query key factory. Despite its breadth, the codebase exhibits well‑defined separation of concerns with reusable UI components (e.g., ItemButton, RoundButton, WImage) and data patterns (e.g., batched metadata fetching, structural sharing for transaction lists). However, there are signs of technical drift, such as hardcoded endpoints, some deprecated library usage, and platform‑specific native modules that require ongoing maintenance.
TZImagePickerController is an iOS library providing a customizable image and video picker controller as a replacement for UIImagePickerController. It features multi-selection, media preview, cropping, video trimming, GIF playback, and original photo selection. The architecture is modular with a main controller (TZImagePickerController) managing navigation, photo browsing (TZPhotoPickerController), preview (TZPhotoPreviewController), and asset management (TZImageManager). Key dependencies include the Photos framework, FLAnimatedImage for GIFs, and optional location services. The library emphasizes customization through appearance properties, UI configuration blocks, and delegate patterns.
This is a full-stack SaaS application for cron job monitoring (cron-job.org). It consists of a React frontend (Material-UI, Redux, i18n), a PHP REST API, a C++ execution daemon named 'Chronos', a WAF validator, and a public status page SPA. The system uses Apache Thrift for inter-service RPC, MySQL for job definitions and user data, per-user SQLite databases for historical execution logs, and Redis for rate limiting. The Chronos daemon implements an efficient async HTTP executor using libcurl, libev, and c-ares, with Prometheus metrics exposure. The codebase is production-grade with features like MFA (TOTP/Yubico), API keys, subscription billing (Stripe/Paddle), status pages with custom domains, and comprehensive i18n. However, it shows signs of technical drift: the frontend uses the deprecated Material-UI v4, password hashing is weak (SHA1+MD5), and the Thrift auto-generated code is fragile. The architecture is well-documented and the core execution engine is highly optimized, but the overall codebase would benefit from modernization of the frontend and authentication layers.