Gem Wallet is a production-grade, self-custodial multi-chain cryptocurrency wallet for iOS (and partially macOS), built entirely with SwiftUI and heavily modularized via Swift Package Manager. The system manages private keys securely via the Keychain and WalletCore, supports 40+ blockchains (Bitcoin, Ethereum, Solana, Cosmos, TON, etc.), and provides full DeFi capabilities: token transfers with fee estimation and simulation, token swaps with provider selection and price impact analysis, staking with delegation and rewards, perpetual trading (Hyperliquid) with leverage and position management, fiat on/off-ramp through third-party providers, NFT viewing and management, WalletConnect dApp connections, price alerts, and a home-screen price widget. Architecture follows an MVVM pattern with protocol-oriented service layers, a centralized dependency injection container (AppResolver), and local persistence via GRDB (SQLite) backed by observable queries for reactive UI updates. Network communication uses a custom HTTP client with device-signed requests and WebSocket streams for real-time balances, prices, and notifications. The codebase is unusually well-tested with dedicated TestKit targets providing mock services for every major component, and extensive unit, UI, and snapshot tests. Despite its size (40+ packages), the modular boundaries are well-observed, with clear abstractions for signing, chain services, and UI components. The project relies on a Rust binary framework (Gemstone) for core blockchain logic, which introduces a build dependency but is managed via a regenerate script. Overall, this is a highly professional, actively maintained iOS application with strong engineering practices.
Jitsu is an open-source event data platform (alternative to Segment) that ingests events from websites, apps, and servers, transforms them via user-defined functions (UDFs) and built-in destination functions, and delivers them to data warehouses (ClickHouse, BigQuery, Snowflake, Redshift, Postgres, S3, GCS) and SaaS tools (Amplitude, PostHog, HubSpot, etc.). The architecture is multi-service: a Go-based bulker handles ingestion and warehouse delivery, a TypeScript-based rotor executes event transformations and profile building, a Next.js console provides the management UI and API, and a CLI tool supports project management and function deployment. The data flow is: HTTP ingest → Kafka → rotor (functions) → bulker (SQL/file destinations) → ClickHouse/PostgreSQL for metrics and logs. External dependencies include Kafka, PostgreSQL, ClickHouse, Redis, MongoDB, and Google Cloud Storage. The console supports multi-tenant workspaces, authentication (Firebase, OIDC, NextAuth), billing, audit logging, rate limiting, and an MCP server for AI tool integration. The codebase is a monorepo with pnpm workspaces and Go modules, featuring extensive test suites (unit, integration with testcontainers, e2e) and CI/CD pipelines. It demonstrates strong engineering practices with reusable libraries (juava, jitsubase), custom high-performance JSON parsers, and well-abstracted repository and configuration patterns. However, there is some technical drift: duplicate JSON libraries (jsoniter and jsonorder), commented-out code, and ESLint disable comments in admin routes. Overall, it is a mature, actively maintained platform suitable for production use.
CherryPy is a mature, object-oriented HTTP framework for Python that provides a full-stack web application server and library. In production, it functions as an HTTP request/response pipeline: incoming requests are parsed by a built-in HTTP server (cheroot), dispatched via pluggable dispatchers (default, method, routes, virtual host) to user-defined handlers, processed through a configurable toolchain (authentication, sessions, caching, compression, static file serving), and returned as HTTP responses. The architecture follows a publish/subscribe bus pattern (the 'engine') that manages server lifecycle—start, stop, restart, graceful shutdown—and allows plugins to hook into these events. Configuration is hierarchical (global, per-application, per-route) and supports namespaces for server settings, tools, hooks, and request/response behavior.
CHAPS (Configuration Hardening Assessment PowerShell Scripts) is a security assessment toolkit designed for Windows systems where additional assessment software cannot be installed. It consists of three script variants (PowerShell v3+, PowerShell v2, and CMD batch) that perform 63 security checks across System Info, Security, Authentication, Network, PowerShell, and Logging categories. All scripts output results in Markdown format to stdout. The companion analysis tool (chaps-analyze.ps1) processes these reports to produce structured findings with recommendations, risk explanations, and MITRE ATT&CK mappings using a JSON knowledge base. The toolkit is specifically designed for ICS/OT environments, air-gapped systems, and locked-down Windows installations where traditional security assessment tools cannot be deployed.
Square Logcat is a lightweight Kotlin multiplatform logging library that provides a simple API for logging on Android and JVM platforms. The library wraps Android's android.util.Log class and offers a similar API for JVM environments. Key architectural decisions include inlined logging functions that avoid string evaluation when logging is disabled, automatic tag extraction from calling class names without stacktrace overhead, and support for multiple concurrent loggers with thread-safe management. The library uses kotlinx.atomicfu for thread-safe collections and follows a clean separation between the logging API (logcat function) and logger installation (LogcatLogger interface).
FreeTDS is an open-source C library that implements the Tabular Data Stream (TDS) protocol, providing client connectivity to Sybase and Microsoft SQL Server databases. It exposes three API layers: DB-Library (compatible with Sybase/Microsoft's db-lib), CT-Library (Sybase's client library), and a full ODBC driver. The library also includes a connection pool server, server-side test infrastructure, and command-line tools such as `tsql`, `fisql`, `freebcp`, `bsqldb`, and `defncopy`. Core protocol handling lives in `src/tds/`, which manages login, authentication (NTLM, Kerberos, SSPI), encryption (TLS via OpenSSL or GnuTLS), packet framing, query submission, cursor management, and bulk copy. The architecture is layered and modular, with clean stream I/O, threading, and character conversion abstractions that make components independently reusable. The codebase is cross-platform (Unix, Windows, VMS) and supports TDS versions 4.2 through 8.0, adapting to server-specific behaviors. Despite its age and some legacy compatibility code, it remains actively maintained and widely used as a reliable database connectivity layer in production environments.
This repository is a Python library and CLI application for parsing, compiling, and calculating Excel formulas and workbooks entirely outside Microsoft Excel. It loads .xlsx, .ods, and JSON model files, builds a directed acyclic computation graph with the schedula library, and evaluates formulas cell-by-cell with support for array formulas, circular references, custom functions, LAMBDA/LET, unit conversions, and sub-model extraction. Primary APIs include ExcelModel, Parser, Ranges, and get_functions(), with additional entry points through a Click CLI (calc, build, test, serve) and a Flask-based web application. Architecturally, the project is a library with CLI and web wrappers. Formula text is tokenized and parsed into an AST, then compiled by AstBuilder into a schedula dispatch pipeline. Workbook loading, reference resolution, and cyclic reference handling are coordinated in the excel package, while hundreds of Excel function implementations are organized in categories such as math, statistics, financial, text, lookup, engineering, and date/time. The function layer relies heavily on numpy, scipy, pandas, statsmodels, and numpy-financial, and uses standardized wrappers to convert Python functions into Excel-compatible array functions with proper error propagation. Strengths include a broad data-driven test suite, an elegant range algebra class, Tarjan-based cycle detection, and a mature parser design. Weaknesses include very large function modules that mix many edge cases, incomplete Excel function categories (Automation, Cube, Database, Web), legacy Python-version conditionals, and heavy external dependencies that may lag behind current Excel behavior. Although the repo contains curated data files and spreadsheet fixtures, its dominant character is a software application rather than a data pipeline or research repository.
Tracee is a runtime security and observability tool that uses eBPF to trace system events and detect threats. It consists of multiple Go binaries: a main security agent (`tracee`) that loads eBPF programs, collects kernel events, and runs detection rules; a gRPC client (`traceectl`) for remote management; an event generator (`evt`) for stress testing; and a Kubernetes operator. The architecture is modular with a clear separation between eBPF event collection, event derivation and enrichment pipelines, data stores (process tree, container info, DNS cache, kernel symbols), a detection engine supporting both Go signatures and YAML-based rules using CEL expressions, and filtering/policy subsystems. The system operates as a daemon with HTTP/gRPC endpoints for metrics, health, and streaming event output, and integrates deeply with Kubernetes via CRDs and controllers. The codebase demonstrates strong engineering with clean abstractions (filter interfaces, data store registries, event derivation framework), reusable utility packages (bucketcache, changelog, string interning, fuzzy parsing), and comprehensive testing including unit, integration, and e2e tests. However, it exhibits technical drift in areas like multiple Go modules with `replace` directives, hardcoded kernel version checks in eBPF probe logic, legacy signature conversion code planned for removal, and some global mutable state. The eBPF C code is complex and kernel-version-sensitive, requiring ongoing maintenance. Overall, it is a well-crafted, production-grade security tool suitable for container and Kubernetes environments.
YAS (Yet Another Shop) is a production-grade, open-source e-commerce platform implemented as a microservices architecture using Java Spring Boot for the backend and Next.js for the frontend (both storefront and admin backoffice). The system is decomposed into ~15 independent microservices (product, cart, order, customer, inventory, payment, promotion, rating, tax, location, media, search, webhook, recommendation, and sample data) that communicate via REST with resilience4j circuit breakers/retries and event-driven patterns using Kafka and Debezium CDC for cross-service data synchronization (e.g., product changes propagate to Elasticsearch for search and PgVector for recommendation). Authentication and authorization are handled via Keycloak with OAuth2/JWT. The architecture includes BFF (Backend For Frontend) gateways using Spring Cloud Gateway and two Next.js frontends. Infrastructure is fully containerized with Docker Compose and Kubernetes Helm charts, with observability via OpenTelemetry, Grafana, Loki, and Tempo. The codebase includes comprehensive unit/integration tests, UI automation tests (Selenium/Cucumber), and CI/CD pipelines per service. While the repository is primarily an application, it incorporates data engineering patterns (CDC, vector embeddings) for the recommendation and search features, giving it a slight hybrid data character. Overall, the code demonstrates solid engineering practices, a well-defined microservice boundary, and several reusable components, though some duplication across services and boilerplate configs exist.
pylsl is a Python binding for the Lab Streaming Layer (LSL), a real-time network protocol for exchanging time-series data, primarily used in neuroscience and biomedical research. The library provides a clean, ctypes-based interface to the native liblsl C library, exposing classes for stream declaration (StreamInfo), data output (StreamOutlet), data input (StreamInlet), and network discovery (resolve_streams, ContinuousResolver). The codebase is well-structured with thorough error handling, graceful degradation for older liblsl versions, and comprehensive test coverage. It includes a micro-benchmarking suite for measuring ctypes call overhead and data conversion costs. The library is actively maintained, with CI/CD pipelines, platform-specific wheels bundling liblsl, and support for Python 3.10–3.13.
Mixpanel-node is a server-side SDK for Mixpanel analytics, providing event tracking, people and group profile management, and feature flag evaluation (local and remote). It includes an optional OpenFeature provider for standardized flag evaluation. The SDK is structured as an npm workspace with two packages: the core `mixpanel` library and `@mixpanel/openfeature-server-provider`. The codebase demonstrates solid engineering practices: clear module separation, comprehensive test coverage with vitest and nock, robust error handling, deprecation warnings, and service account authentication support. The feature flags subsystem includes custom json-logic operators for semver and datetime comparison, validated against cross-platform golden vectors. The OpenFeature provider correctly maps Mixpanel's fallback reasons to OpenFeature error codes. Dependencies are modern, and the project is actively maintained with automated CI/CD and release workflows.
This repository provides a Python library for parsing human-readable time expressions into seconds. The core functionality is implemented in the `timeparse` function, which accepts strings in various formats (e.g., '32m', '2h32m', '1w3d2h32m', '4:13:02', '2 days, 4:13:02') and returns the equivalent duration in seconds as an integer or float. The library handles optional signs, fractional values, and ambiguous colon-separated values via a granularity parameter. It has no external dependencies and is designed for simplicity and reliability. The library is structured as a single module with a clear public interface. The implementation uses a series of regular expressions to match different time formats and converts the matched components to seconds using predefined multipliers. The code is well-tested with a comprehensive test suite that covers the various input formats and edge cases. Despite its simplicity, the library demonstrates careful attention to detail in handling the complexities of time expression parsing, such as supporting both written and abbreviated units, handling spaces and commas as separators, and providing control over the interpretation of colon-separated values.
RectifiedFlow is a unified PyTorch library for implementing Rectified Flow models, a type of generative model that learns ordinary differential equations to transform data between distributions. The library provides a modular framework for training various architectures (MLP, UNet, DiT, LightningDiT) on different datasets, with support for multiple sampling algorithms and interpolation schemes. Key features include a symbolic solver for affine interpolation equations, utilities for converting between different interpolation schemes while preserving rectified flow properties, and a flexible sampler base class for implementing custom integration methods. The codebase demonstrates strong software engineering practices with clear separation of components, comprehensive documentation through examples, and active maintenance.
This Chef cookbook provides custom resources for managing APT (Advanced Package Tool) configuration on Debian-family Linux distributions (Debian 12+, Ubuntu 22.04+). It is a resource-first cookbook, meaning it does not ship recipes or attribute-driven configuration; instead, users declare resources like `apt_config`, `apt_cacher_client`, `apt_cacher_ng`, and `apt_unattended_upgrades` in their wrapper cookbooks. The cookbook handles base APT update behavior, dpkg options, proxy configuration for apt-cacher clients, installation and configuration of the apt-cacher-ng caching proxy server, and unattended-upgrades setup including debconf preseeding. It relies on Chef Infra Client >= 15.3 and the underlying APT system; no external cookbook dependencies are required. The architecture is a set of Chef custom resources (in `resources/`) backed by ERB templates (in `templates/`) and a small library module (in `libraries/`). Each resource encapsulates idempotent actions: creating or deleting configuration files, installing or removing packages, and managing services. The cookbook includes comprehensive ChefSpec unit tests and InSpec integration tests, with CI/CD via GitHub Actions and Test Kitchen with Dokken. It follows modern Chef patterns (unified_mode, action_class, lazy property defaults) and is actively maintained by the Sous Chefs community. Key entry points are the four custom resources. Typical data flows: a user declares a resource in a recipe; Chef converges by writing templates to `/etc/apt/apt.conf.d/`, installing packages (e.g., `apt-cacher-ng`, `unattended-upgrades`), and managing services. The `apt_config` resource also sets up periodic `apt_update` runs and creates helper directories for preseeding. The cookbook does not expose any API endpoints or CLI tools; it is purely a configuration management library for Chef.
This repository contains a minimal coding agent designed to work with local Ollama models. The agent operates in a loop, processing user requests by inspecting and modifying the workspace through a set of structured tools (file operations, shell commands, etc.). It implements six core components: live repo context collection, prompt shaping with cache reuse, structured tools with validation and permissions, context reduction and output management, transcript and memory persistence, and bounded delegation to subagents. The agent is implemented in a single Python file (`mini_coding_agent.py`) and is intended to be run via a CLI entry point. It requires an Ollama server running with a compatible model (default: qwen3.5:4b). The code is clean, well-structured, and demonstrates thoughtful agent design patterns, making it a useful reference for building similar agents.
This repository is a Rust library providing structured concurrency primitives for async programming. It offers operations such as `join`, `race`, `try_join`, `race_ok` for futures, and `merge`, `chain`, `zip` for streams, supporting tuples up to 12 elements, arrays, and `Vec` (with alloc feature). It also includes `FutureGroup` and `StreamGroup` for dynamic collections, and a `ConcurrentStream` trait for processing streams concurrently with backpressure and bounded concurrency. The library is runtime-agnostic (works with tokio, async-std, smol, etc.) and supports `no_std` environments. The code extensively uses pin projection, `ManuallyDrop`, and custom waker arrays with bit-set readiness tracking to achieve efficient polling and cancellation. It provides benchmark comparisons against `futures-rs` demonstrating competitive performance. There are no data pipelines, notebooks, or research elements; this is a pure library for async concurrency.
BQt is a Blender add-on that integrates PySide6 QtWidgets with Blender, allowing developers to create custom UIs for their add-ons using Qt. The system wraps Blender's native window in a Qt container, manages the Qt event loop alongside Blender's main loop, and provides widget management to ensure Qt widgets stay properly parented and visible relative to Blender windows. It handles platform-specific window management for Windows and macOS to maintain proper focus and activation behavior, including a native event filter that forwards WM_ACTIVATE events on Windows to prevent focus issues when multiple Blender windows are open. The architecture features a modular design with abstract base classes for platform-specific implementations, clean separation of concerns between widget management, application logic, and utilities, and follows Blender add-on conventions.
Linkook is a Python CLI tool for OSINT-driven discovery of linked social media accounts and associated emails across multiple platforms. It takes a single username as input, scans a configurable set of websites (defined in a provider.json file), and recursively extracts linked accounts, usernames, and emails from discovered profiles. The tool supports breach checking via HudsonRock's database or Have I Been Pwned, and can export results to a Neo4j-compatible JSON format for graph visualization. The architecture is modular: a Provider class handles URL templates and regex extraction, a SiteScanner performs HTTP requests and keyword-based existence checks, and a ScannerManager manages concurrent scanning via a thread pool with a queue. The code is well-structured, includes unit tests, and demonstrates solid engineering practices with clean separation of concerns, error handling, and logging.
VimWiki is a mature Vim/Neovim plugin implementing a personal wiki system for note-taking, task management, documentation, and diary keeping. It features syntax highlighting for multiple markup languages (default VimWiki, Markdown, MediaWiki), wiki link resolution, table formatting, tag generation, and HTML export. The architecture follows a modular autoload pattern with scoped variable management (global, wiki-local, syntax-local, buffer-local) enabling flexible configuration. Core functionality includes link handling, diary automation, and text object manipulation for lists/tables. The project maintains active development with comprehensive testing across Vim/Neovim versions via CI, demonstrating strong adherence to Vim plugin best practices.
This repository is a comprehensive library of Kyverno policies for Kubernetes, providing a curated collection of Validating, Mutating, Generating, and Cleanup policies. It covers Pod Security Standards (baseline and restricted), best practices, RBAC restrictions, image registry controls, and integrations with ecosystem tools like Istio, Linkerd, Karpenter, and ArgoCD. The policies are written as YAML manifests using Kyverno's CEL-based API (policies.kyverno.io/v1) and are accompanied by extensive test suites using both Chainsaw and Kyverno CLI frameworks. The repository serves as a reference implementation and distribution channel for Kyverno users, with standardized metadata (ArtifactHub), CI/CD pipelines, and contribution guidelines. While not a traditional application, it functions as a policy-as-code library with a strong emphasis on security and operational best practices.