Trussed is a no_std Rust library and framework for building cryptographic firmware on microcontrollers. It implements a client-service syscall architecture: applications use strongly-typed client traits such as CryptoClient, FilesystemClient, and CertificateClient to send Request enums through an interchange channel; Service::process dispatches requests to pluggable mechanism implementations or custom backends, persists keys and files across three littlefs2 filesystems (internal, external, volatile), and returns Reply enums. It is not a standalone application or CLI but an embedded component used by firmware runners such as Solo 2 and Nitrokey 3.
FreakWAN is a LoRa-based wide-area network (WAN) messaging system designed for ESP32 and T-ECHO devices. It implements a fully distributed, open chat network independent of internet or cellular infrastructure. The system supports plaintext and encrypted messaging, group chats, media sharing (small images), sensor data collection, and includes features like duty cycle tracking, automatic retransmission with ACK suppression, and neighborhood discovery via HELLO messages. The codebase is written in MicroPython (with a C port for T-ECHO) and is entirely self-contained, relying only on standard libraries. Architecturally, the application runs as a single asyncio event loop with multiple tasks for periodic message sending, HELLO advertising, serial input handling, and optional IRC/Telegram bot integration. The radio layer is abstracted behind SX1276 and SX1262 drivers, and the display uses a terminal-like Scroller view with splash screen and status icons. The protocol layer defines message types (Data, Ack, Hello, Ping, Pong) and supports encryption via AES-CBC with HMAC integrity. The repository is well-structured, with clear separation of concerns and reusable components that can be extracted for other projects.
This repository is a production-grade Discord bot for managing support tickets, built with TypeScript and the discord.js core library. It provides a complete ticket lifecycle: users open tickets via panels (select menus or buttons), staff can claim, close, reopen, rename, add/remove participants, and the bot generates transcripts via ticket.pm. The architecture follows a modular feature-based pattern with automatic discovery of commands, events, and feature modules from the filesystem. The bot uses SQLite (via drizzle-orm and libsql) for persistence, supports internationalization (English and French), and includes telemetry, update checking, and migration scripts from v3 to v4. Key entry points are the slash commands (/add, /claim, /close, /reopen, /remove, /rename, /unclaim, /cleardm, /mass_add) and interactive components (buttons, selects, modals). External dependencies include Discord API, libsql, drizzle-orm, ticket.pm SDK, and typesafe-i18n.
The Atata Framework is a full-featured C#/.NET test automation framework primarily designed for web UI testing via Selenium WebDriver. It implements a fluent page object model where test pages are represented as typed classes with controls declared as properties, configured through attributes for element location (FindByLabel, FindByCss, etc.), interaction behaviors (ClickBehaviorAttribute, ValueSetBehaviorAttribute), and lifecycle triggers (WaitForAttribute, VerifyTitleAttribute). The framework goes beyond WebDriver integration to provide a universal testing infrastructure including session management with borrowing and pooling, an event bus for lifecycle hooks (AtataContext init/deinit, session events), configurable logging with nested sections and secret masking, and a verification system with should/expect/wait strategies that support retrying assertions. The architecture is builder-driven: AtataContextBuilder configures the test context (culture, timeouts, events), while WebDriverSessionBuilder sets up browser drivers (Chrome, Firefox, Edge, etc.) with screenshot and page snapshot strategies. The system is designed to be extensible through custom attributes, event handlers, log consumers, and strategy implementations. External dependencies include Selenium.WebDriver, and optional adapters for NUnit, xUnit, MSTest, and Reqnroll. The included test application (Atata.TestApp) is a Razor Pages fixture used by integration tests, not a production artifact.
This repository provides a build system for version-stable Rocker Docker images for R, including r-ver, rstudio, tidyverse, verse, shiny, shiny-verse, and geospatial. The core architecture uses R scripts to generate Dockerfiles from templates and docker-bake.json files from version matrices, enabling reproducible builds with fixed CRAN snapshots, RStudio Server versions, and CTAN dates. The CI/CD pipeline (GitHub Actions) automatically updates container definitions, builds multi-platform images (linux/amd64 and linux/arm64), and publishes them to Docker Hub and GitHub Container Registry. The repository also contains a collection of standalone installation scripts (rocker_scripts) that can be reused in downstream Dockerfiles to install R, RStudio Server, Shiny Server, tidyverse packages, geospatial libraries, Python, Julia, Jupyter, and more. These scripts are parameterized, idempotent, and follow best practices for Docker image layering. The build system itself is a well-engineered example of code generation and matrix-based CI, though it is tightly coupled to the Rocker project's specific versioning scheme.
Equinox is an F# library for event-sourced systems, providing a consistent abstraction over multiple stream-based storage backends including CosmosDB, DynamoDB, EventStoreDB, MessageDB, SqlStreamStore, and an in-memory store. In production, it enables applications to define domain logic as pure decision functions that produce events, while the library manages optimistic concurrency, caching, snapshots, and retries. The core is the `Decider` pattern: an aggregate loaded from a stream, a decide function that returns events, and a fold that applies events to produce new state. Access strategies (e.g., `LatestKnownEvent`, `RollingSnapshots`, `Custom`) control how state is reconstructed from stored events, trading read cost for write cost. The architecture is modular: the `Equinox` package defines the core interfaces (`ICategory`, `IStream`, `Decider`), while separate NuGet packages implement storage adapters. The library is used as a dependency in larger applications; sample projects (`Store/Domain`, `TodoBackend`, `Tutorial`) demonstrate its use. Key entry points include the `Decider` class for command/query execution, `Category` for resolving streams, and store-specific connectors (e.g., `CosmosStoreConnector`, `DynamoStoreConnector`). A CLI tool (`Equinox.Tool`) provides provisioning, benchmarking, and data inspection commands across all stores. External dependencies are minimal per package: `Equinox` depends only on `FsCodec` for serialization; store adapters require their respective SDKs (Azure.Cosmos, AWSSDK.DynamoDBv2, EventStore.Client, Npgsql, etc.). The library includes comprehensive caching (`Equinox.Cache` wrapping `System.Runtime.Caching.MemoryCache`), metrics via Prometheus, and a load testing harness. Despite some deprecated adapters (legacy EventStore TCP, SqlStreamStore) and high complexity from multiple backends, the core patterns are clean, well-tested, and production-proven at Jet.com.
This repository is a benchmark suite for comparing the performance of different programming languages in solving the 'related posts' problem: given a list of posts with tags, compute the top 5 related posts for each post based on shared tags. The architecture consists of language-specific implementations (over 50 languages) that all follow the same algorithm: build a tag-to-post-index map, then for each post count shared tags via that map, and select the top 5 posts using a custom priority queue. The repository includes Dockerfiles for each language, helper scripts for running benchmarks, and a workflow that automates execution across multiple post counts (5k, 20k, 60k) and updates a README with results. The code demonstrates strong engineering practices: consistent algorithm across implementations, use of language-specific optimizations (e.g., SIMD, custom hash maps, parallelization), and careful attention to performance measurement (excluding I/O).
Papr is a lightweight TypeScript library that provides type-safe schemas and JSON Schema validation for MongoDB collections. It wraps the official MongoDB Node.js driver, offering a familiar API (find, insertOne, updateOne, etc.) while automatically generating JSON Schema validators that are applied to MongoDB collections via `collMod` or `createCollection`. The library supports a wide range of BSON types, timestamps, defaults (static, dynamic, async), hooks (before/after), and custom filter types for enhanced type safety in queries and updates. It is designed as a thin, performant alternative to Mongoose, offloading validation to the MongoDB server. The codebase is well-structured with modular source files, extensive unit and type tests, benchmarks comparing performance against raw MongoDB driver and Mongoose, and comprehensive documentation. It is actively maintained with CI/CD pipelines, automated releases, and dependency management via Renovate.
Polyglot is a Ruby gem that serves as a Jekyll plugin for internationalization (i18n) of static sites. It enables building a site in multiple languages by forking the Jekyll build process per language, patching core Jekyll classes (`Site`, `StaticFile`) to handle language-specific files, and providing Liquid tags for SEO headers (`I18n_Headers`) and URL relativization control (`static_href`). The plugin coordinates documents across languages, supports fallback to the default language, localizes `site.data` via language-specific subdirectories, and generates Netlify-compatible redirects. It is not a standalone application but a library that integrates deeply with Jekyll via hooks and monkey-patching. The repository includes a comprehensive demo site with 18 languages, a full RSpec test suite, CI via CircleCI, and extensive documentation in both README and `ai_docs/`. The codebase is well-structured, with clear separation of concerns (hooks, patches, liquid tags), and demonstrates non-trivial engineering in areas like parallel forking, regex-based URL relativization, and document coordination.
go-webdav is a Go library implementing WebDAV (RFC 4918), CalDAV (RFC 4791), and CardDAV (RFC 6352) protocols. It provides client and server implementations for these protocols, with a clear separation between the HTTP handling layer and storage backends via a FileSystem interface. The library includes a command-line tool to run a WebDAV server serving a local directory. The architecture is modular, with core WebDAV functionality in the 'webdav' package, CalDAV and CardDaV extensions in their respective packages, and low-level HTTP/XML handling in the 'internal' package. The library depends on go-ical and go-vcard for calendar and contact data processing.
vkbottle is an asynchronous Python framework for building VK (VKontakte) bots and interacting with the VK API. It provides both high-level abstractions (Bot, User, labelers, rules, middlewares, state dispensers) and low-level API clients with pluggable request/response validation, token rotation, and error handling. The framework is fully async, built on asyncio and aiohttp, and supports long polling, callback API, and dual mode (simultaneous polling and callback). It includes extensive tooling for keyboards, templates, uploaders, markdown-to-VK-format conversion, VKScript generation, event deduplication, and a waiter machine for awaiting future events. The architecture is modular with abstract base classes for nearly every component, enabling custom implementations. The codebase is well-structured with clear separation of concerns, extensive test coverage, and CI/CD pipelines. Deprecated components (LoopWrapper, Blueprints) are clearly marked, and the library is actively maintained with a mature version 4.11.0.
This repository provides a SQLAlchemy dialect for DuckDB, enabling DuckDB to be used as a database backend within SQLAlchemy's ORM and Core APIs. It maps DuckDB's type system to SQLAlchemy types, handles connection management (including in-memory and file-based databases), supports reflection (schema introspection), and integrates with DuckDB extensions. The dialect is built on top of the PostgreSQL psycopg2 dialect, customizing it for DuckDB's capabilities and limitations. The source code is well-structured, extensively tested, and actively maintained, with support for DuckDB versions 0.5.0 through 1.2.2 and SQLAlchemy 1.3 through 2.0.35.
Ralph Wiggum for Cursor is an implementation of Geoffrey Huntley's Ralph Wiggum technique for autonomous AI development. It manages LLM context like memory by tracking token usage and rotating to fresh agent contexts when needed, persisting state in files and git. The system provides automated iteration loops with features like gutter detection, rate limit handling, task progress tracking via checkboxes, and support for both sequential and parallel execution modes. Key components include a sophisticated stream parser for real-time token and error monitoring, a YAML-backed task parser with caching, and retry logic with exponential backoff.
Pktgen is a high-performance, scriptable packet generator built on top of DPDK. It generates wire-rate traffic with support for Ethernet, IPv4/IPv6, TCP/UDP, GRE, GTP-U, MPLS, VLAN, and other encapsulations. The application provides an interactive CLI with auto-complete, history, and environment variables, as well as Lua scripting for automation. It includes features like latency measurement, packet capture/replay, range-based packet field sweeping, random bitfield generation, and RFC 2544 throughput testing. The architecture is a monolithic DPDK application with modular libraries for CLI, Lua bindings, hash maps, vectors, plugins, and common utilities. It is designed for network testing, benchmarking, and research scenarios requiring precise traffic generation and measurement.
Blackfire Player is a PHP CLI application (blackfire-player) that executes declarative scenario files to crawl HTTP services, extract data, and assert responses, with integrated Blackfire performance profiling. It uses a custom DSL (`.bkf` files) to define sequences of steps (visit, click, submit, loop, while, etc.) and supports concurrent execution via PHP Fibers. The architecture is modular: a step hierarchy (AbstractStep, Step, etc.), dedicated step processors following the Chain of Responsibility pattern, an extension system for lifecycle hooks (before/after step, scenario), and a Symfony ExpressionLanguage wrapper providing scraping-specific functions (css, xpath, json, regex, fake, etc.). The tool integrates with the Blackfire SDK for profiling and assertion checks, and outputs results as JSON or text. It is distributed as a PHAR archive and a Docker image, built via GitHub Actions. The codebase is well-structured, heavily tested with PHPUnit, and follows modern PHP practices (typed properties, strict types, PHP 8.4+ features).
This is a GitHub Action that automates creating releases in Sentry (error monitoring platform). The action wraps the `@sentry/cli` tool and runs as either a Docker container on Linux runners or a composite action installing the CLI on macOS/Windows. Its core workflow (in `src/main.ts`) parses inputs, validates environment variables, then orchestrates a sequence of sentry-cli calls: creating a release, optionally setting commits (auto/skip/manual), injecting debug IDs into source files, uploading source maps, deploying to an environment, and finalizing the release. Telemetry via `@sentry/node` is collected to monitor action performance. The codebase is small (5 source files plus tests), cleanly structured, and well-tested with both unit tests and end-to-end integration tests against Sentry's API. It is actively maintained with recent dependency bumps and proper CI/CD pipelines.
Tilus is a tile-level GPU kernel programming language and compiler framework, primarily targeting NVIDIA architectures (SM80, SM90, SM100). It provides a Python DSL (`tilus.Script`) for writing high-performance CUDA kernels with explicit management of shared/register memory, tensor cores (WGMMA, tcgen05), and advanced synchronization primitives (mbarrier, cluster sync, TMA). The compiler stack includes a custom IR with layout inference (register/shared/tensor-memory), a pass pipeline (dead code elimination, bound-aware simplification, sub-byte type lowering), and backend emitters that generate PTX/CUDA code. Autotuning over tile sizes, warp counts, and pipeline stages is built into the framework. The architecture separates concerns into three layers: the user-facing `lang` package (Script, autotune, instructions), the `ir` package (tensors, layouts, instructions, inference rules), and the `backends` package (emitters, contexts, code generation). The `hidet` subpackage integrates a vendored copy of the Hidet IR and transforms, which provides the low-level expression/statement IR and a comprehensive set of optimization passes. Examples cover progressive matmul implementations (V0–V6) for Ampere, Hopper, and Blackwell, as well as flash attention, layer norm, and quantization kernels. This is a research project (ASPLOS '26 paper) with a strong emphasis on correctness and performance, evidenced by CUDA-level validation against PyTorch and cuBLAS. While the codebase is well-structured and demonstrates advanced compiler design patterns, it remains in beta (version 0.2.0) and carries some duplication between vendored Hidet code and native Tilus code, as well as hardware-specific constraints (NVGPU only). The layout inference system and autotuning infrastructure are particularly notable as reusable components.
DockYard/elixir-mail is an Elixir library for building, parsing, and rendering email messages according to RFC 2822 and related MIME standards. It provides a composable API to create simple and multipart email messages, handle various transfer encodings (Base64, Quoted-Printable, 7bit, 8bit, binary), and parse incoming email into structured data. The library is structured around a core `Mail.Message` struct with separate modules for encoding, parsing, rendering, and MIME type lookup. It does not require any external runtime dependencies beyond the Erlang/OTP standard library.
Euclid is a Rust library providing type-safe geometric primitives with compile-time unit checking to prevent mixing of different coordinate spaces. It implements 2D/3D points, vectors, transforms, and related types using phantom types for unit safety, enabling operations like transformations, intersections, and conversions while maintaining FFI compatibility. The library is used in the Servo browser engine for layout and rendering, featuring generic scalar types, operator overloading, and optional integrations with serde, bytemuck, and mint. Its core strength lies in the unit-tagged generic system that catches unit mismatches at compile time, a pattern applicable beyond graphics to any domain requiring dimensional analysis.
PipelinR is a lightweight Java library implementing the mediator/pipeline pattern for command processing. It provides a type-safe way to send commands to handlers through a configurable pipeline of middleware, supporting cross-cutting concerns like logging, validation, and transactions. The library also implements notification (event publishing) with multiple handling strategies including synchronous, asynchronous, and parallel execution modes. With zero dependencies and a focus on simplicity, it aims to help developers follow SOLID principles by replacing monolithic service classes with focused handlers.