This repository is a Laravel package that extends the framework's localization capabilities to include country-specific formatting. It provides a middleware that automatically detects the user's preferred language and country from browser headers or user profile, sets session variables, and offers a facade with methods to retrieve localized date formats, currency symbols, country names, and emoji flags. It also includes a language switcher controller and listens to login events to persist user preferences. The architecture follows Laravel's service provider pattern, with a main LangCountry class that reads data from bundled JSON files for each supported locale. The package integrates with Carbon for date formatting and provides Carbon macros for convenient use. The codebase is well-tested with 100% coverage, typed, and follows PSR-12 coding standards. The most reusable component is the PreferredLanguage service, which encapsulates the logic of parsing the Accept-Language header and matching against allowed locales with quality weighting and fallback. This could be extracted into a standalone library for browser language detection in any PHP project.
Kalker is a multi-platform, feature-rich calculator application written primarily in Rust, with web (Svelte + WASM) and mobile (Android via Capacitor) frontends. The core kalk library provides a lexer, parser, AST interpreter, and a numeric value system supporting real, complex, vector, and matrix arithmetic with arbitrary precision (via the rug crate) or standard f64. It includes user-defined variables and functions, calculus operations (differentiation, integration), equation solving via Newton-Raphson inversion, and a comprehensive set of built-in mathematical functions. The CLI offers a REPL with syntax highlighting and tab completion, while the web component is published as an npm package for embedding. The architecture is modular with a clear separation between parsing, evaluation, and frontend, though some code duplication exists between the two numeric backends.
Diun is a Docker image update notifier written in Go that monitors container images across various platforms (Docker, Kubernetes, containerd, Nomad, Swarm, and file-based configurations) for updates. It periodically checks image manifests against a stored state (using BoltDB) and sends notifications via multiple channels (Slack, Telegram, email, etc.) when updates are detected. The application features a modular architecture with pluggable providers and notifiers, a gRPC interface for external interaction, Prometheus metrics, and structured logging. The system is designed for self-hosted environments to automate the detection of base image updates, application releases, and security rebuilds. Key components include a CLI for management, a scheduler for periodic checks, a template system for customizable notifications, and secret handling utilities. Diun's strength lies in its extensibility and wide platform support, making it a versatile tool for DevOps workflows.
python-hyperscan is a CPython extension providing Python bindings for Vectorscan (a fork of Intel's Hyperscan), a high-performance multiple regex matching library. The library enables efficient pattern matching with statically linked binaries and cross-platform support. It exposes most of the Hyperscan C API through Python classes including Database for pattern compilation, Scan for text scanning, Stream for streaming processing, and Scratch for thread-safe scratch space management. The implementation features proper buffer protocol support, sophisticated GIL handling for both traditional and free-threaded Python models, and careful resource management. The build system uses scikit-build-core with CMake to statically link Hyperscan/Vectorscan along with dependencies like PCRE and Boost, producing binary wheels for multiple platforms.
MiroFish is a full-stack web application that implements a swarm intelligence prediction engine. It ingests real-world documents (PDF, Markdown, TXT), extracts seed information via LLM-driven ontology generation, builds a knowledge graph using Zep Cloud, and then generates agent profiles and simulation configurations for the OASIS multi-agent simulation framework. The system runs dual-platform simulations (Twitter-like and Reddit-like) to model social evolution and produce predictive reports through a ReACT-based report agent that queries the knowledge graph and interviews simulated agents. The frontend is a Vue 3 SPA with a 5-step wizard guiding users through graph building, environment setup, simulation execution, report generation, and deep interaction with agents. The architecture follows a monolith-with-subprocesses pattern: a Flask backend serves REST APIs for graph management, simulation lifecycle, and report generation, while simulation subprocesses run independently and communicate via a file-based IPC protocol. The system relies heavily on external services: an OpenAI-compatible LLM API for generation tasks, Zep Cloud for persistent graph storage and retrieval, and the OASIS simulation engine. The codebase is well-structured with clear separation into API routes, service modules, utility functions, and frontend components. It includes comprehensive i18n support (7 locales), Docker deployment, and CI/CD via GitHub Actions. While primarily an application, MiroFish has strong data/research characteristics: its core value proposition is predictive simulation driven by LLM-generated ontologies and agent profiles, and it uses GraphRAG techniques for report generation. The repository includes standalone scripts for star history tracking and validation, but these are auxiliary to the main application. The code demonstrates good engineering practices with reusable utilities (LLM client with retry, Zep pagination, file parser, retry decorators) and a consistent pattern for asynchronous task management and polling.
CyberClaw is an enterprise-grade transparent AI agent architecture that implements a dual-watermark memory system, full behavior auditing, zero-trust execution via two-phase skill invocation, and a heartbeat task engine for scheduled operations. The system provides an interactive conversational interface where users can query time, perform calculations, manage files, execute shell commands within a secure sandbox, and utilize pluggable skills. All agent actions are transparently logged to JSONL files for monitoring and compliance. The architecture features clean separation of concerns with distinct modules for agent logic, skill loading, context management, logging, heartbeat tasks, and tool execution.
Tokimeki is a full-featured, open-source Bluesky client built with SvelteKit and TypeScript. It provides a multi-column deck layout (similar to TweetDeck) with support for multiple accounts, real-time timeline updates, chat (direct and group), rich media embeds, custom moderation (keyword mutes, labelers), and extensive customization (themes, keyboard shortcuts, layout options). The application uses the AT Protocol (XRPC) for all Bluesky interactions, implements OAuth and password-based authentication, and includes a service worker for push notifications and offline caching. Architecturally, Tokimeki is a single-page application (SPA) with server-side routes for OAuth flows, AI features (alt text generation, column icon suggestions), and proxy endpoints. State management is handled via Svelte 5 runes ($state, $derived) and custom reactive classes (ColumnState, AppState, PostState). Data persistence uses IndexedDB (via Dexie) for accounts, bookmarks, and drafts, and localStorage for settings. The codebase is modular with clear separation of concerns: UI components in src/lib/components/, state classes in src/lib/classes/, utilities in src/lib/, and routes in src/routes/. It includes a comprehensive test suite using Vitest and Playwright. Key features include a custom feed merge engine for combining multiple timelines, a virtual scrolling system with Fenwick tree for efficient rendering, an image compression pipeline with WebAssembly and fallback, a full chat system with group management, and an atmosphere service registry for third-party integrations. The application is internationalized with 10+ locales and supports on-device translation via the browser's Translator API.
Gratatouille is a framework for building Gradle plugins using a functional programming approach. It processes Kotlin functions annotated with @GTask, @GPlugin, and @GExtension via KSP to generate complete Gradle plugin implementations including task classes, workers, entry points, and descriptor files. The framework enforces classloader isolation to prevent dependency conflicts and provides automatic build caching, parallel execution, and automatic task wiring. Generated code follows Gradle best practices with proper input/output annotations and up-to-date checks.
Maple Mono is an open-source monospace programming font with an extensive build system. The repository is primarily a font engineering toolchain: it takes Glyphs source files, generates variable and static TTF/OTF/WOFF2 fonts, auto-hints them, patches in Nerd Font icons, merges Chinese/Japanese base fonts, and produces dozens of variants (hinted/unhinted, ligature/no-ligature, narrow/slim, etc.). The build is orchestrated by Python scripts (`build.py`, `task.py`) and supports customization via CLI flags or a `config.json` file. A web playground service (`in_browser.py`) allows users to build custom fonts in-browser with selected OpenType features. The codebase is not a running service but a build toolchain with a strong focus on OpenType feature engineering—featuring a custom AST-based DSL for programmatically generating ligature, character variant, and stylistic set feature files. The repository is well-maintained with active GitHub Actions workflows, though the v7 branch is explicitly a frozen snapshot of the current stable release (development continues on the `variable` branch).
This repository provides `ulab`, a C extension module for MicroPython and CircuitPython that implements a carefully selected subset of NumPy and SciPy functionality, optimized for microcontrollers with limited RAM and flash. In production, it compiles into firmware and exposes `ulab.numpy` (array creation, linear algebra, FFT, random, universal functions, I/O), `ulab.scipy` (signal processing, numerical integration, optimization, special functions), and utility modules for buffer conversion. The architecture is a monolithic C library that hooks into MicroPython's object system, using a heavily macro-driven approach to support 1-4 dimensional ndarrays with broadcasting, views, and type promotion. Key entry points are the `ndarray` type and the top-level modules. Data flows involve user-created arrays, element-wise or reduction operations (often with an optional `out` parameter to minimize allocations), and optional file I/O in .npy or text format. External dependencies are limited to the MicroPython/CircuitPython runtime. Although primarily an application library, it includes a Python fallback layer (`snippets/`) that enables the same code to run on CPython, and extensive Jupyter notebooks serve as interactive documentation and benchmarks.
Win2D is a production-grade Windows Runtime 2D graphics library that wraps Direct2D, DirectWrite, Direct3D, and WIC into a WinRT API for use in UWP and WinUI3 applications. It provides immediate-mode GPU-accelerated rendering through XAML controls (CanvasControl, CanvasAnimatedControl, CanvasSwapChainPanel), drawing sessions, brushes, geometries, text layout and analysis, SVG documents, printing, and over 70 image effects. The library is packaged as a NuGet package (Microsoft.Graphics.Win2D) and supports C#, C++/CX, C++/WinRT, and VB.NET consumers. Architecturally, Win2D is a WinRT component implemented in C++/WinRT with a DLL entry point (module.cpp) that registers activation factories and telemetry. The core rendering logic lives in winrt/lib/, organized by subsystem: drawing (CanvasDrawingSession, DeviceContextPool), effects (generated wrappers and custom pixel shader support), text (DirectWrite wrappers), geometry, brushes, SVG, printing, and XAML controls. A code generation tool (tools/codegen) produces IDL and effect implementations from XML definitions, ensuring consistency across the large effect surface. The library relies on external dependencies including Direct2D, DirectWrite, Direct3D 11, Windows Imaging Component (WIC), and the Windows App SDK (for WinUI3). Key entry points for developers are the XAML controls (CanvasControl, CanvasAnimatedControl) which provide CreateResources and Draw events, and the CanvasDrawingSession which exposes all drawing operations. The library also includes extensive interop interfaces (ICanvasImageInterop, ICanvasResourceWrapperNative) for integrating with native Direct2D code. Testing is comprehensive, with internal C++ unit tests using mocks/stubs, external integration tests with real devices, and managed C# tests.
rules_ios is a Bazel rule set for building Apple platform applications (iOS, macOS, tvOS, watchOS). It provides rules for creating apps, frameworks, extensions, app clips, tests, and handling Apple-specific complexities like code signing, resource bundling, and multi-architecture support. The repository integrates with rules_apple and rules_swift, offering a Bazel-native alternative to Xcode builds. Key features include automatic handling of Apple Silicon compatibility via import_middleman, VFS overlays for faster builds, and comprehensive test generation. The tooling directory contains utilities like arm64-to-sim for running arm64 binaries in x86_64 simulators and SSH password helpers for VM-based testing.
Packmind is a developer productivity platform that centralizes engineering standards and distributes them to AI coding agents. It solves the problem of scattered standards (in Slack, Notion, PR comments) that AI agents can't access and the manual copy-pasting of standards across repositories. The platform provides organization/space-based collaboration, Git provider integrations, LLM/AI service abstraction, marketplace for sharing components, deployment/target management, and change proposal workflows. It features a hexagonal architecture with clear separation of concerns across domains (accounts, organizations, spaces, standards, skills, commands, deployments), using NestJS for the backend, React for the frontend, and a separate CLI tool for local artifact management.
This repository provides a complete, production-ready solution for converting LoctekMotion/FlexiSpot standing desks into smart, Home Assistant-integrated devices. The core of the project is a set of ESPHome YAML packages and custom ESPHome components that communicate with the desk controller over a serial (UART) interface via an RJ45 connection. The firmware decodes the desk's proprietary 7-segment display protocol to report height as a sensor, and sends commands (up, down, presets, memory, alarm, child lock) to control the desk. It supports both direct connection (using a spare RJ45 port) and pass-through configurations (intercepting the keypad line). The repository includes well-structured, parameterized YAML configurations for ESP32 and ESP8266, custom C++ sensor components for height and keypad command decoding, and Python code generation stubs for ESPHome. Archived Arduino sketches and a Raspberry Pi Python script are also provided for alternative implementations. The project is actively maintained, uses modern tooling (uv, ruff, pre-commit, CI), and demonstrates strong embedded systems and protocol reverse-engineering skills.
ZLS (Zig Language Server) is a comprehensive implementation of the Language Server Protocol (LSP) for the Zig programming language. Written entirely in Zig, it provides rich IDE features including code completion, go-to-definition, hover information, semantic tokens, inlay hints, code actions, diagnostics, document symbols, folding ranges, signature help, and workspace symbol search. The server integrates with Zig's build system via the Build System Protocol (BSP) and can run `zig ast-check` for diagnostics, or use its own built-in semantic analysis engine. Architecturally, ZLS is a monolithic LSP server with a modular design. The core `Server` struct manages workspaces, document stores (`DocumentStore`), configuration (`Config`), and dispatches requests to feature modules under `src/features/`. The `Analyser` struct in `src/analysis.zig` provides type inference and symbol resolution using an `InternPool` for deduplicated type/value storage. A newer analysis backend under `src/analyser/` (InternPool, StringPool, degibberish) is partly implemented but not yet fully integrated. The test suite is extensive, with over 9,000 lines of completion tests alone, using a custom testing framework and placeholder-based assertions. Key dependencies include `known-folders` for platform-specific directory discovery, `diffz` for text diffing, `lsp_kit` for LSP protocol types, and `tracy` for profiling. The build system is managed via `build.zig` with dependency definitions in `build.zig.zon`. ZLS is highly configurable through a JSON configuration file, with options for snippets, inlay hints, build-on-save, and more. It is actively maintained, targets Zig master, and has a strong focus on correctness and performance, though some areas (like generic resolution and combinatorial types) remain heuristic-based.
Harmonica is a Python library for forward modeling, processing, and inversion of gravity and magnetic data, part of the Fatiando a Terra project. It provides high-performance, Numba-accelerated kernels for computing gravitational and magnetic fields of various geometric bodies (prisms, tesseroids, point masses, ellipsoids, dipoles) and supports equivalent source interpolation, frequency-domain grid transformations (upward continuation, reduction to pole, derivatives), spherical harmonic models (IGRF), and Euler deconvolution. The library is designed for geoscientists and educators, integrating tightly with the scientific Python ecosystem (xarray, scikit-learn, pygmt, verde). It features a scikit-learn-like API for its gridder classes, extensive documentation and testing, and is actively maintained as part of the Fatiando project. While its core functionality is domain-specific, the code exhibits strong software engineering practices: modular architecture, Numba JIT compilation, consistent interfaces, and comprehensive CI/CD.
This repository is a comprehensive configuration and extension set for Anthropic's Claude Code AI coding assistant. It enhances Claude Code with a sophisticated hook system for event-driven automation, a specialized agent delegation system for task-specific AI assistants, and an activity tracking mechanism that injects context-aware guidance based on user behavior. The system also includes templates for generating project documentation and integrates with external services like Pushover for notifications. While it contains example documentation for a game project (likely 'Mystica'), its primary purpose is to provide a customizable development environment for AI-assisted software engineering.
CheatReader is a Flutter-based desktop ebook reader designed for low-distraction reading. It provides a floating, always-on-top window that supports single-line and multi-line reading modes, transparency, a boss key for quick hide/restore, system tray integration, and app disguise (icon/name change). The application imports local files in multiple formats (txt, epub, html, md, fb2, docx, pdf) via text extraction, never modifying the source. It features a bookshelf with reading progress tracking, customizable keyboard shortcuts, auto page-turn, full-text search, and a control panel for all settings. The architecture is a standard Flutter app with platform-specific abstractions for window management, file import, and startup behavior, targeting Windows, macOS, and Linux. The codebase is well-tested, localized in English and Chinese, and uses a spec-driven development process (OpenSpec). While the main reader surface widget is large (~2600 lines), the overall structure demonstrates solid engineering with reusable patterns for platform abstraction, settings persistence, and text extraction.
This is a GitHub Action that parses JaCoCo XML coverage reports and posts a formatted coverage summary as a comment on pull requests. It supports single and multi-module projects, aggregate reports, multiple counter types (INSTRUCTION, BRANCH, LINE, COMPLEXITY, METHOD), custom emojis, and comment update strategies. The action fetches the list of changed files from the PR via the GitHub API, computes overall and per-file coverage percentages, and renders a markdown table with pass/fail indicators based on configurable thresholds. The codebase is written in TypeScript, well-structured with clear separation of concerns (action orchestration, XML parsing, coverage computation, markdown rendering), and includes a comprehensive test suite with fixtures covering various report structures and edge cases.
Crawlkit is a shared Go library and CLI tool (crawlctl) for building local-first crawler archives. It provides provider-neutral building blocks including SQLite stores with FTS5, snapshot/export to gzipped JSONL shards, Git-based mirroring with immutable tags, encrypted backup with age/gzip and SHA-256 deduplication, sync state management with legacy adapters, vector search (exact cosine similarity and optional turbovec Python bridge), embedding providers (OpenAI, Ollama, llama.cpp), a terminal UI (Bubble Tea) for browsing archive rows, and a remote archive client for Cloudflare Workers. The CLI discovers installed crawl apps (e.g., gitcrawl, discrawl) and runs configured refresh jobs under a single-process lock. The architecture is modular and composable, with clear ownership boundaries documented in docs/boundary.md. The repository also includes agent skills (autoreview, crabbox) for automated code review and remote validation, reflecting heavy agent-driven development. It is not a generic web crawler but a mechanics layer that makes each crawl app smaller and more uniform.