svg2jsx is a web application that converts SVG markup into valid JSX code for React components. It provides a real-time editor with a split pane: left for SVG input (with drag-and-drop support) and right for the generated JSX output. The conversion pipeline runs server-side via a Next.js API route, applying SVGO optimization, attribute normalization (camelCase, className, style objects), and optional formatting as a React component (with memo, TypeScript, and quote configuration). The frontend is built with React 18, Next.js 15, TanStack Query, Tailwind CSS, and react-ace for the editor. The codebase is well-structured, with clean separation of concerns between UI components, state management (React Context), and pure conversion logic. Tests cover the core conversion function. The app is designed for single-user, client-side usage with a simple API endpoint.
This is an Obsidian plugin that integrates large language models (LLMs) directly into the note-taking environment. It provides a template-driven text generation system using Handlebars with custom async helpers, supports multiple LLM providers (OpenAI, Anthropic, Google Gemini, Mistral, Ollama, Perplexity, HuggingFace, Together AI, MiniMax, Azure, and custom endpoints), and offers content extraction from PDF, audio, images, YouTube, RSS, and web pages. The plugin includes a community template marketplace, auto-suggest, an overlay toolbar, a playground for testing templates, and extensive Obsidian integration (commands, views, settings, CodeMirror extensions). Architecturally, it is a client-side monolithic plugin that communicates directly with external LLM APIs and the npm registry for package management. The codebase is large (300+ files) and well-organized into providers, extractors, UI components, and services, but it shows some drift due to hard-coded model lists and deprecated provider support (e.g., Google PaLM). The async Handlebars helpers and generic caching utility are highlight components that could be extracted for reuse in other projects.
This repository implements a complete quantitative trading framework for A-shares, known as 'zettaranc-skill'. It is a dual-track project: (1) a Python/Rust software application providing CLI tools, a FastAPI REST API, and a React frontend for stock analysis, backtesting, simulation, screening, and strategy optimization; (2) an AI character-play skill pack that encodes a specific trading methodology (Zettaranc/Shaofu strategies) into a SKILL.md for LLM role-play. The application side dominates: it has 15+ CLI subcommands, a modular architecture with 30+ technical indicators, 20+ strategy detectors, a multi-source data layer (Tushare, Indevs, A-Stock-Data, Hithink, SQLite), a Rust-accelerated backtesting engine (via PyO3), a walk-forward simulation framework, and a self-optimization pipeline. The codebase is well-structured with clean abstractions (DataSource protocol, unified error codes, parameter registration), extensive test coverage, and CI/CD. However, it suffers from some technical drift: dual Python/Rust implementations must stay synchronized, Chinese vernacular naming reduces readability, hardcoded constants persist, and the self-optimizer's LLM judge is a stub. Overall, it is a production-grade personal quant framework with high craftsmanship in its core components.
This repository is the official pre-commit hook distribution point for the Ruff linter and formatter. Its primary function is to act as a lightweight, automated bridge between the Ruff project on PyPI and the pre-commit ecosystem. It does not contain Ruff's source code; instead, it provides the hook definitions (`.pre-commit-hooks.yaml`) that allow users to run `ruff check` and `ruff format` through pre-commit, with the actual tool being downloaded from PyPI. The architecture is a model of focused automation. The core logic resides in `mirror.py`, a PEP 723 compliant Python script designed to run on a schedule via GitHub Actions. This script automatically detects new Ruff releases on PyPI, updates the version pin in `pyproject.toml` and the documentation in `README.md`, and then commits, tags, and creates a GitHub Release for the new version. This ensures the repository is perpetually up-to-date without any manual intervention. The codebase demonstrates high craftsmanship within its narrow scope. The `mirror.py` script is exceptionally well-structured, using modern Python features like inline script metadata, the `packaging` library for robust version handling, and idempotent git operations. The CI/CD pipeline is equally well-designed, handling conditional pushes and release creation with clear, concise shell scripting. While the repository is small, every line of code serves a clear purpose and is executed with precision, making it a reliable and trustworthy component in the Python development toolchain.
This is a personal Home Assistant configuration repository for automating a smart home. It uses Home Assistant's core automation system supplemented with AppDaemon for complex Python-based automations, HACS for managing community integrations, and Lovelace for custom UI. The configuration controls lighting, climate, security, media players, vacuum robots, and plant monitoring, with integrations for devices like Philips Hue, Xiaomi Aqara, KEF speakers, LG OLED TV, and Roborock. The repository demonstrates good organization through modular includes for reusable configuration snippets, functional separation of automations by domain, and clear separation between YAML-based and Python-based automation approaches.
mesh-sdk-go is a Go SDK for building Rosetta/Mesh API integrations, the blockchain-agnostic API standard originally developed by Coinbase. It ships both sides of the wire: generated OpenAPI HTTP clients (client/), generated server controllers with router wiring (server/), and a set of runtime engines layered on top. The fetcher wraps API calls with exponential-backoff retries, a connection semaphore, and mandatory response validation; the syncer performs concurrent block fetching with reorg detection; the reconciler compares locally computed account balances against live node state; the parser extracts balance changes, groups operations, and matches operation intents; and the constructor module defines transaction-building workflows in a custom DSL (.ros files) executed by a worker/coordinator pipeline. The keys package implements signers for secp256k1 (including BIP-340 Schnorr), secp256r1, ed25519, and Pallas curves. Architecturally this is a library, not a standalone service: host applications implement service interfaces (BlockAPIServicer, AccountAPIServicer, etc.) and either serve HTTP via server.NewRouter or consume a node through client/fetcher. The block/transaction data flow is node → fetcher → asserter validation → syncer → storage (BadgerDB) → reconciler; construction flows in the reverse direction: DSL workflow → worker execution → key signing → broadcast submission. The types/ directory holds roughly 85 auto-generated Rosetta data models, and templates/ plus codegen.sh regenerate client, server, and types from the mesh-specifications OpenAPI spec. Key external dependencies include BadgerDB, btcec, kryptology, and go-ethereum crypto packages. The codebase is professionally structured: 10+ packages, essentially all with table-driven tests, functional-options configuration, error-sentinel patterns, and mockery-generated mocks. Maintenance is active as of late 2026, with CI, dependabot (0 alerts), and regular commit activity. Technical drift is medium: the repo is mid-rebrand from rosetta-sdk-go (internal import paths and RosettaAPIVersion constants still use the old name), BadgerDB v2 is aging, and a zstd dictionary-training step shells out to a system binary. None of this blocks use today, but adopters should expect regeneration friction and naming inconsistencies as the Mesh rebrand completes.
Fetch is a Scala library for simple and efficient data access, built on cats-effect. It provides a monadic abstraction (`Fetch[F, A]`) that automatically optimizes data fetching through batching, caching, deduplication, and parallel execution. Users define data sources by implementing the `DataSource` trait, specifying how to fetch individual identities or batches. The library then composes fetches using standard monadic and applicative combinators, transparently batching requests to the same source and running independent fetches concurrently. It supports custom caches, optional fetches, error handling, and debugging via a separate `fetch-debug` module. The architecture is a pure library with no runtime dependencies beyond cats-effect, making it suitable for both JVM and Scala.js. Key entry points include `Fetch.apply`, `Fetch.run`, `Fetch.runLog`, and `Fetch.runCache`. External dependencies are minimal: cats-effect, cats-core, and scalatest for testing.
Foliate is a desktop e-book reader for GNOME/Linux, built with GTK4, Libadwaita, and GJS (GNOME JavaScript). It supports EPUB, Mobipocket, Kindle, FB2, CBZ, and PDF formats, using WebKitGTK to render book content via a custom JavaScript rendering engine (foliate-js). The application provides a full-featured reading experience with paginated and scrolled modes, customizable fonts and themes, annotations (highlights, notes, bookmarks), text-to-speech via Speech Dispatcher, OPDS catalog browsing, and dictionary/Wikipedia lookups. Architecture: The main entry point is src/main.js, which initializes the GJS application and loads the GResource-bundled source files. The core UI is defined in src/app.js (window creation, file handling) and src/book-viewer.js (reading view with sidebar, search, navbar, TTS). The library view (src/library.js) manages book collections and OPDS integration. Reading state (annotations, bookmarks, progress) is persisted per-book as JSON files in the user's data directory. The rendering pipeline lives in the WebView: src/reader/reader.js handles content display, CSS injection, and footnotes, while the foliate-js submodule parses e-book formats into a pageable model. External dependencies: GNOME platform (GTK 4.12, Libadwaita 1.8, WebKitGTK 6.0, GJS 1.82), Speech Dispatcher for TTS, Tracker (optional) for file indexing, and third-party APIs (Wiktionary, Wikipedia, Google Translate) for lookup tools. The build system uses Meson, with Flatpak and Snap packaging provided. Internationalization across 30+ languages is maintained via gettext PO files. Data flows: User opens a file → book is parsed by foliate-js into a structured document model → rendered in WebView → user interactions (scroll, search, annotate, bookmark) are communicated back to GJS via the WebView's async RPC pattern (exec/iter/provide) → state is persisted as JSON files. OPDS catalogs are fetched via HTTP and rendered in a separate WebView frontend (src/opds/main.html).
GFast is a full-stack, modular admin panel built with GoFrame v2.10 and Vue3. It provides a RESTful API backend for managing users, roles, departments, menus, dictionaries, configuration, logs, and system monitoring. The architecture follows a layered pattern: API definitions (api/v1), controllers (internal/app/*/controller), business logic (internal/app/*/logic), data access objects (dao), and service interfaces. Authentication uses JWT (gfast-token) and authorization uses Casbin with RBAC. Caching is abstracted via gfast-cache supporting memory or Redis. The system includes a code generator, scheduled tasks, and an OpenAPI/Swagger endpoint. External dependencies include MySQL, Redis, Casbin, and ip2region for IP geolocation.
This repository contains the `jx` CLI, the primary command-line interface for the JayeX (Jenkins X) 3.x platform. It is a Go application that provides a modular command tree for managing Kubernetes-native CI/CD pipelines, including commands for namespace switching, dashboard access, version management, and self-upgrade. The CLI acts as a launcher for external plugin binaries (e.g., jx-gitops, jx-secret) that are discovered and executed dynamically, with built-in shell completion delegation. The architecture is centered around the Cobra command-line framework and integrates with Kubernetes APIs, GitHub releases for plugin distribution, and the local filesystem for configuration and binary caching. While the core is tightly coupled to the JayeX ecosystem, the plugin management and self-update subsystems exhibit patterns that could be extracted for use in other CLI tools.
This repository is primarily an 'awesome list' curating fuzzing (fuzz testing) resources - books, talks, papers, tools - organized by venue and type. The core content lives in a single README.md file. What distinguishes it from a simple list is a set of well-engineered Python scripts (ndss.py, sp.py, usenix.py) that automatically scrape conference accepted-paper pages (NDSS, IEEE S&P, USENIX Security) and match titles containing 'fuzz'. For IEEE S&P, the sp.py script goes further by verifying bibliographic metadata via the Crossref API before proposing entries, ensuring only validated DOIs are suggested. These scripts are triggered manually via GitHub Actions workflows, generating pull requests rather than writing directly. The code exhibits careful HTML parsing with validation, idempotent update logic, comprehensive error handling, and extensive unit tests. While the repository's primary output is a static list, the supporting automation demonstrates production-quality data collection and proposal pipelines that could be reused for maintaining other curated lists.
WhiteSur Icon Theme is a comprehensive SVG icon set for Linux desktop environments (GNOME, KDE, XFCE, Budgie, etc.) that emulates the macOS Big Sur visual style. It provides over 28,000 icons covering applications, devices, places, status indicators, mime types, and more, organized into multiple sizes (16, 22, 24, 32, scalable) and color variants (default, light, dark, and accent colors). The repository includes a well-structured Bash installer script (install.sh) that copies icons to the user's icon directory, creates symlinks for HiDPI scaling, and supports optional bold panel icons, alternative icons, and KDE Plasma logo replacement. The theme is actively maintained with a large community following. While not a software application in the traditional sense, it is a high-quality design asset pack with a robust installation mechanism.
This repository serves as the central hub for the W3C Positive Work Environment Community Group, which maintains and evolves the W3C Code of Ethics and Professional Conduct (now referred to as the Code of Conduct). The system consists of static HTML documents (some using ReSpec for technical report formatting), Markdown files, presentation templates, and educational resources. Key functions include: maintaining the Code of Conduct document and its update procedures; documenting dispute resolution processes including mediation, investigations, and disciplinary actions; describing the Ombudsperson program; providing meeting facilitation training materials (Running Better Meetings guides); managing inclusion fund proposals and communications; and offering multilingual versions of core documents. The architecture is a static document repository with presentation layers powered by Shower.js and custom CSS frameworks. External dependencies include ReSpec for document formatting and Shower.js for slide presentations, both loaded from W3C domains.
This is a TypeScript library (v3.1.5) that wraps the Steam Web API, providing a clean, fully typed interface to interact with Steam's official and some undocumented endpoints. It is distributed as an ES module on npm under the name 'steamapi'. The library is architected around a single main class (`SteamAPI`) instantiated with an API key, which exposes methods for resolving Steam IDs, fetching game details, user profiles, achievements, badges, friends, bans, servers, and more. All API responses are parsed into strongly typed structure classes (e.g., `GameDetails`, `UserSummary`, `NewsPost`). It includes built-in configurable in-memory caching for game details and user resolution to reduce repeated API calls, and supports custom caching via a simple interface. The code is well-structured with clear separation of concerns between API logic, data models, and utility functions, and uses modern TypeScript features like interfaces, generics, and accessors. While it is not architecturally groundbreaking, it is a solid, professional-grade SDK that effectively encapsulates a complex external API with consistent error handling, caching strategies, and comprehensive type definitions. There are no significant reusable components that could be cleanly extracted to a new project, as the value lies in the integration with Steam's API, but the caching implementation and structure patterns provide a good reference for similar API wrapper projects.
Lux is a Lua package manager and developer toolchain implemented as a Rust workspace. It is a true application, not a data/research project. The primary entry point is the `lx` CLI (`lux-cli/src/bin/lx.rs`), which dispatches roughly 40 subcommands covering dependency management, installation, building, testing, linting, formatting, vendoring, publishing, and project scaffolding. Underneath, `lux-lib` provides the core engine: rockspec parsing/execution, dependency resolution, lockfile management, source fetching with integrity verification, multi-backend builds, install-tree management, Lua version detection, and LuaRocks-compatible packaging. The workspace also includes `lux-lua` (a Lua API library), `lux-lsp` (progress reporting for language servers), `lux-macros` (proc macros for Lua serialization), and Nix packaging helpers. The primary data flow begins with `lux.toml` project files and workspace manifests. The dependency resolver (`lux-lib/src/pipeline/resolve.rs`) uses a package database chain and concurrent discovery to produce a package graph, which is materialized into a `lux.lock` lockfile with SRI hashes, version constraints, source URLs, and entrypoints. Packages are downloaded from LuaRocks-compatible servers, git remotes, or vendored directories, then built through backends for builtin, make, cmake, rust-mlua, rust-binary, and tree-sitter parsers. Final artifacts are installed into versioned rock trees or flat dist trees, and a Lua loader (`lux-lua/src/loader.rs`) makes those packages requireable from Lua. External dependencies include LuaRocks.org servers, git, C/CMake toolchains, optional Lua installations, and an optional external manifest cache service. Lux is actively maintained and shows strong engineering practices: consistent builder-pattern APIs, typed diagnostics, well-structured error enums, extensive integration tests, cross-platform CI, and a sophisticated Nix overlay. However, it is still pre-1.0 and evolving quickly, with many breaking changes in recent releases. Known weaknesses include non-transactional install operations, hardcoded Lua version hashes, several unsafe code paths, a very large `lua_impls.rs` file, and some disabled CI matrix entries for Lua 5.5 and LuaJIT. Overall, this is a mature and feature-complete package manager with genuinely reusable low-level components.
This repository is the official Russian localization pack for the colony-sim game RimWorld, covering the base game (Core) and all major DLCs (Royalty, Ideology, Biotech, Anomaly) plus the third-party Odyssey content mod. It is predominantly a data repository: roughly 1,780 XML files in RimWorld's standard DefInjected/Keyed layout, where each entry overrides an English game string with a Russian translation and preserves the English source as an inline comment. The pack is the canonical Russian translation distributed with game updates, making it a hybrid asset — mostly localization data with a thin application layer of tooling and grammar code. The application layer is thin but purposeful. LanguageWorker_Russian.cs implements RimWorld's language-worker interface with Russian-specific grammar handling — pluralization (three plural forms), gender agreement, and case inflection backed by WordInfo data files. A GitHub Actions pipeline of eight Python scripts validates XML well-formedness, UTF-8/BOM encoding, dash formatting, gender-macro consistency, and reportString punctuation on every push, catching the class of copy-paste errors that plague large translation corpora. The translation data itself uses RimWorld's macro system ({PAWN_gender}, {lookup:...Case;...}) to produce grammatically correct Russian in dynamic game contexts, including procedural name generation via RulePackDef translations. The repository is actively maintained (last commit 2026-09-13) and tracks current game versions including the Anomaly DLC. Its most reusable assets are the CI validation scripts — encoding, XML, and gender-consistency checks applicable to any localization project — and the Russian grammar logic in the language worker. The XML corpus is project-specific but demonstrates a disciplined pattern for large-scale Slavic localization. Known weaknesses include occasional translation inconsistencies (e.g., copy-paste errors in drug-tolerance stage labels where 'large' is translated as 'medium') and the maintenance burden of tracking rapid game updates across six content areas.
Safety is a commercial CLI tool for software supply chain security, primarily scanning Python (and limited npm) dependencies for known vulnerabilities. It operates as a multi-command CLI built with Click and Typer, offering commands such as `scan`, `check`, `auth`, `firewall`, `init`, and `codebase`. The architecture is modular: a core scanning engine (`safety/scan/`) discovers dependency files (requirements.txt, pyproject.toml, Pipfile.lock, etc.), resolves packages, and matches them against a proprietary vulnerability database fetched from the Safety platform. Results are formatted via a pluggable formatter system (JSON, HTML, screen, text, SPDX) and can be uploaded to the platform for reporting. The tool also includes a firewall mode that intercepts pip/poetry/uv/npm install commands to block malicious packages in real time, using shell aliases (Unix) or registry/autorun (Windows). Authentication is multi-modal: OAuth2 (browser-based), API keys, and machine tokens, with a complex enrollment flow for enterprise MDM. An internal event bus (`safety/events/event_bus/bus.py`) provides async telemetry and audit trail emission, used throughout auth, init, and scan workflows. The codebase demonstrates strong engineering practices: layered configuration resolution (CLI > env > config file > default), a command wrapper pattern for package managers, and a policy file system (YAML) for ignoring vulnerabilities by severity, CVSS score, or expiration. However, there is notable technical drift: the legacy `check` and `license` commands are deprecated but still present, typing is incomplete in several modules, and the Windows firewall interceptor relies on fragile registry manipulation. The test suite is extensive but heavily mocks external services, making integration tests brittle. External dependencies include `httpx`, `authlib`, `tenacity`, `rich`, `pydantic`, `dparse`, `packaging`, `certifi`, `filelock`, and the proprietary `safety-schemas` package. The tool is distributed as a PyPI package and as a GitHub Action, with CI/CD pipelines building platform-specific binaries via PyInstaller and PyApp. Overall, Safety is a mature, feature-rich security tool with a well-architected core, though some areas show signs of rapid feature growth and legacy debt.
Pydub is a mature, high-level Python library for audio manipulation. It provides an immutable `AudioSegment` class that supports slicing, concatenation, overlaying, gain changes, fading, and format conversion using ffmpeg/avconv as a backend for non-WAV formats. The library includes a variety of DSP effects (normalize, speedup, compression, filters, equalization), silence detection/splitting, signal generators (sine, square, sawtooth, white noise), and optional playback via simpleaudio, pyaudio, or ffplay. Its architecture is modular, with core functionality in `audio_segment.py` and effects registered via a decorator pattern. The codebase demonstrates clean abstractions and is well-tested, though it carries some legacy Python 2 compatibility patterns.
py2exe is a specialized build tool and library designed to freeze Python scripts into standalone Windows executables (.exe). It supports console applications, GUI applications, and Windows services. The architecture consists of a Python package (py2exe) that analyzes dependencies and bundles code, combined with C-based runtime stubs (MemoryModule, run.exe, etc.) that embed the Python interpreter and execute the frozen script from memory or disk. The primary entry point is the `py2exe.freeze()` API, which replaces the deprecated `distutils`/`setup.py` interface. It relies heavily on `pefile` for binary analysis and `setuptools` for packaging. The tool is actively maintained, supporting Python versions 3.10 through 3.14. It features a robust hook system for handling complex third-party packages like NumPy, SciPy, and Matplotlib. The codebase demonstrates high craftsmanship in its C integration for memory-based DLL loading and dependency scanning, making it a critical tool for distributing Python applications on Windows without requiring a Python installation.
Serie is a Rust terminal user interface (TUI) application that renders git commit history graphs using terminal image protocols (iTerm2, Kitty, Kitty Unicode). It provides a rich, interactive commit graph viewer with features like commit detail view, refs tree, user-defined commands, search, and customizable keybindings. The application is designed as a focused git log/graph viewer, not a full git client. The architecture is event-driven with a main loop managing multiple views (commit list, detail, refs, help, user command). It uses a custom graph layout algorithm to compute commit positions and edges, then renders each graph row as a PNG image via the `image` crate, which is uploaded to the terminal using the appropriate image protocol. The UI is built with `ratatui` and `crossterm`. Key components include a sophisticated graph rendering pipeline with antialiasing support, a flexible keybinding system with conflict detection, a configuration system with schema validation, and an event system with background input handling. The codebase demonstrates strong Rust craftsmanship with clean abstractions, extensive snapshot testing for graph rendering, and careful state management for view refresh. While the application is primarily a practical tool for developers, its graph layout algorithm and antialiased image rendering modules contain non-obvious algorithmic work that could be extracted for other terminal graphics projects. The codebase is actively maintained with CI/CD pipelines, documentation, and release automation.