pycrdt is a Python library providing bindings for Yrs, the Rust port of the Yjs CRDT framework. It enables real-time collaborative editing by offering shared data types (Text, Array, Map, XmlFragment, etc.) that automatically merge concurrent modifications across distributed replicas. The library implements a full transaction system, event observation, document synchronization protocols, awareness management, undo/redo functionality, snapshots, and typed containers with static type analysis support. The architecture is a hybrid Python/Rust package using PyO3 for the FFI layer, with the heavy lifting done in the `yrs` Rust crate. The Python layer provides clean, idiomatic interfaces with both synchronous and async APIs, leveraging `anyio` for async transaction and event handling. The library is well-tested with 100% code coverage, includes extensive documentation, and follows modern packaging practices with `maturin` for building and publishing. It is suitable for building collaborative applications such as real-time text editors, whiteboards, or any multi-user data-sharing system.
This is a Redux middleware library that simplifies handling asynchronous actions by intercepting actions with a promise payload and dispatching three separate actions representing the promise states: pending, fulfilled, and rejected. It supports implicit and explicit promise definitions, async functions, optimistic updates via payload.data, and custom type suffixes and delimiters. The middleware is well-structured, fully tested with a comprehensive suite covering edge cases like null/boolean/numeric resolutions, async functions, and third-party promise libraries. It is a mature, stable library with nearly 2000 stars, widely used in the Redux ecosystem. The codebase is clean and follows best practices, though it uses some older tooling versions (Babel 7, Jest 24, Webpack 4).
ewebsock is a Rust WebSocket client library designed to compile and run both natively and on the web via WASM. It provides a simple, uniform API (`connect`, `ws_connect`, `ws_receive`) that abstracts away platform differences: on native it uses `tungstenite` with either a dedicated thread (default) or an opt-in `tokio` backend, while on web it wraps the browser `WebSocket` API via `web-sys`/`wasm-bindgen`. The library handles binary and text messages, ping/pong, connection lifecycle events, and supports TLS (rustls) and custom headers/subprotocols. It is small, well-documented, and heavily feature-flagged to keep dependencies minimal, making it suitable for GUI apps (e.g., egui) that need real-time communication across desktop and browser targets. The codebase is clean and exhibits strong craftsmanship: the separation of backends is clean, error handling is thorough (including read timeouts and graceful shutdown), and the web implementation carefully manages Blob/ArrayBuffer conversion and memory-safe closure lifetimes. The repository also includes an example egui app and an echo server for testing. While it is primarily a library, it is also an application in the sense that it ships executable examples. Overall, it is a mature, well-maintained crate with a clear API and robust platform abstraction.
Boost.MySQL is a high-quality, production-ready C++11 client library for MySQL and MariaDB, built on top of Boost.Asio. It provides both synchronous and asynchronous database access with a modern, type-safe interface. The library features a sans-I/O architecture that separates protocol logic from transport, enabling testability and flexibility. Key capabilities include connection pooling with automatic health checks, client-side SQL formatting to prevent injection, prepared statements, pipeline batching, and a static interface using Boost.Describe or Boost.Pfr for compile-time row mapping. The codebase demonstrates strong engineering practices: extensive unit and integration tests, fuzzing, thread-safety verification, and benchmarks against native MySQL clients. It is an official Boost library, actively maintained with a large community.
This repository provides TransmittableThreadLocal (TTL), a Java library that extends InheritableThreadLocal to propagate thread-local values across threads even when using thread pools, executors, ForkJoinPool, and other asynchronous constructs. It solves the common problem of context loss (e.g., tracing, security, session) in asynchronous Java applications. The library offers three usage modes: manual wrapping of Runnable/Callable via TtlRunnable/TtlCallable, wrapping executors via TtlExecutors, and transparent bytecode transformation via a Java Agent (TtlAgent) that automatically instruments JDK thread pool classes. The architecture is modular: ttl-core contains the core API and CRR (Capture-Replay-Restore) pattern, ttl-agent provides the agent with Javassist-based transformlets, ttl-kotlin adds Kotlin extensions, and ttl-integrations includes Vert.x 3/4 support. A ttl2-compatible module maintains backward compatibility with the v2 API. The library is widely adopted in the Java ecosystem (e.g., Apache ShardingSphere, SOFARPC) and is under active development with a v3 branch introducing a refined API. While primarily a library, it includes a Java Agent component that operates at the JVM level, making it a hybrid of library and instrumentation tool.
Twikit is an asynchronous Python library that provides a comprehensive, unofficial client for the Twitter (X) API. It allows users to perform a wide range of Twitter operations—such as posting tweets, searching for tweets and users, managing bookmarks and lists, sending direct messages, uploading media, and streaming real-time events—without requiring an official API key. The library achieves this by reverse-engineering Twitter's internal GraphQL and REST v1.1 endpoints, handling authentication via login flows or guest tokens, and implementing sophisticated anti-bot evasion techniques like client-side transaction ID generation (X-Client-Transaction-Id) and UI metrics obfuscation. The architecture separates concerns into GraphQL (gql) and REST (v11) client modules, with data models for tweets, users, communities, and more. It includes optional CAPTCHA solving and cookie persistence for session reuse. The codebase is well-structured, actively maintained, and demonstrates deep reverse-engineering skill, particularly in the `x_client_transaction` module that mimics Twitter's client-side telemetry.
Ratpack is a lightweight, reactive web framework for the JVM built on Netty and Java 8. It provides an asynchronous execution model based on Promise/Operation, a flexible handler chain for request processing, pluggable configuration from multiple sources, and a Registry-based dependency injection system. The framework includes first-class Groovy DSL support, a comprehensive test harness, and integrations with Spring Boot, Google Guice, Dropwizard Metrics, multiple template engines (Handlebars, Thymeleaf, Rocker, Groovy), Redis for session storage, and reactive libraries (RxJava 2, Reactor). The codebase is modular with over 30 subprojects, extensive Spock test coverage, and a Gradle plugin for continuous reloading. While the public API is well-designed and documented, the internal packages are tightly coupled to Netty internals and some integration modules may lag behind external library versions.
This is a Rust library providing an async client for InfluxDB 1.x and 2.x (compatibility mode). It supports writing and reading data via the InfluxDB HTTP API, with a fluent query builder for constructing line protocol write queries and read queries. The library offers optional serde integration for deserializing query results into Rust structs using a custom Serde deserializer that handles InfluxDB's column/value array format. It also includes a derive macro (`InfluxDbWriteable`) for automatically generating write queries from structs. The architecture is centred around a `Client` struct that wraps a `reqwest` HTTP client, with support for authentication (basic auth and token-based) and multiple HTTP backends via feature flags. The codebase is well-structured, with clean separation of concerns, extensive unit and integration tests, and a strong emphasis on correct line protocol escaping. The custom serde deserializer is a notable highlight, demonstrating advanced Serde patterns for transforming array-of-arrays into map-like structures. The project is actively maintained with recent commits and a clear release process.
PowerThreadPool is a high-performance .NET thread pool library designed for managing both synchronous and asynchronous workloads with granular control. It implements a low-contention thread pool using work-stealing priority queues, lock-free synchronization primitives, and sophisticated state management for workers and work items. The library provides features like work dependency tracking, group-based operations, pause/resume/cancel controls, timeout/retry policies, and event-driven monitoring. Architecture centers around the PowerPool class managing Worker instances that execute work from concurrent collections, with async support via custom synchronization contexts. Entry points include QueueWorkItem overloads for submitting work and control methods like Start/Stop/Pause/Resume. The library targets .NET Framework 4.0+ through .NET 5+ and netstandard, demonstrating careful backward compatibility through conditional compilation.
Smol is a lightweight async runtime for Rust that bundles several well-known subcrates (async-executor, async-io, async-net, async-fs, async-process, async-channel, async-lock, blocking, futures-lite) into a single convenient dependency. It provides a global executor initialized lazily with configurable thread count via the SMOL_THREADS environment variable, and exposes a simple API (smol::spawn, smol::block_on, smol::Async, smol::Timer, smol::Unblock, etc.) for writing async programs. The source code itself is thin—primarily re-exports from subcrates plus a spawn module that sets up the global executor. This makes smol an excellent entry point for Rust async development without the complexity of larger runtimes like tokio. The repository includes a rich set of examples covering TCP, TLS, HTTP, WebSocket, file I/O, process management, and platform-specific features like inotify and timerfd. The codebase is well-maintained, uses modern Rust practices (edition 2021, MSRV 1.85, no unsafe), and has active CI and dependabot configuration.
Goose is a high-performance, Rust-based load testing framework designed to simulate realistic HTTP/HTTPS user traffic. It functions as both a reusable library and a CLI tool, allowing developers to write load tests in Rust that are compiled into standalone binaries. The architecture relies on the Tokio async runtime for efficient concurrency, utilizing flume channels to decouple virtual user threads from the main metrics aggregation process. It supports complex test scenarios including weighted transactions, session data management, and custom protocol simulation (TCP, WebSocket, gRPC). The framework distinguishes itself through rigorous metric accuracy, specifically implementing mitigation strategies for Coordinated Omission (CO) to prevent misleading latency data during server stalls. It provides extensive reporting capabilities, generating HTML reports with ECharts visualizations, JSON metrics for CI/CD integration, and PDF reports via headless Chrome. Runtime control is available through Telnet and WebSocket interfaces, allowing test parameters to be adjusted dynamically without stopping the load generation. While the core library is stable and well-architected, the project exhibits signs of active but evolving development. The distributed testing feature (Gaggle) was removed and is currently being re-implemented, indicating ongoing architectural shifts. The project maintains a comprehensive documentation suite via mdBook but faces challenges in synchronizing documentation across multiple locations (README, CHANGELOG, mdBook, inline code). The AI-assisted development workflow relies on external APIs that may introduce dependency risks if those services change. For engineers evaluating reuse, Goose offers a robust foundation for performance testing with strong type safety guarantees in its client builder. The Coordinated Omission mitigation logic is a unique, high-value component for teams concerned with metric accuracy. However, users should be aware of the optional PDF dependency (Chrome) and the current instability of the distributed testing mode. The codebase is suitable for integration into CI/CD pipelines or as a library for custom performance validation tools.
kr8s is a Python client library for the Kubernetes API that provides both synchronous and asynchronous interfaces, designed to be familiar to users of kubectl. The core implementation is async-first, with sync wrappers generated via an anyio-based bridging layer, ensuring a single source of truth for all logic. The library includes built-in classes for common Kubernetes resources (Pod, Service, Deployment, Node, Job, etc.), dynamic class creation for custom resources, and support for exec, port forwarding, watching, and client caching. Authentication is handled through kubeconfig files, service accounts, exec plugins, OIDC, and direct tokens, all abstracted behind a unified KubeAuth class. The architecture is modular: the main entry points are `kr8s` (sync) and `kr8s.asyncio` (async), with the heavy lifting in `kr8s/_api.py`, `kr8s/_objects.py`, and several utility modules. The library is extensively tested with pytest and Kind clusters, and includes a full featured CLI example (`kubectl-ng`) that reimplements kubectl commands using kr8s, rich, and typer. Documentation is comprehensive, covering installation, authentication, object operations, and guides for building operators. Quality is solid: clean separation of concerns, thoughtful caching (vendored asyncache), robust error handling, and a well-documented API. The primary weakness is the monolithic `_objects.py` (1000+ lines) and the manual sync/async wrapping, which can introduce maintenance overhead. Overall, kr8s is a professionally maintained, production-ready Kubernetes client that stands out for its simplicity and extensibility.
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 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.
libplctag.NET is a .NET library providing two NuGet packages for industrial PLC communication via EtherNet/IP and Modbus TCP. The primary package (libplctag) offers a high-level, asynchronous, strongly-typed API built on top of the native libplctag C library, handling resource cleanup, exceptions, and event-driven operations. The second package (libplctag.NativeImport) exposes a low-level P/Invoke wrapper that manages platform-specific native binary loading and provides raw tag access. The architecture is a classic wrapper layer: the high-level Tag class encapsulates native handle lifecycle, attribute string generation, synchronous and async operations (using TaskCompletionSource with concurrent stacks to handle native callbacks), and exposes typed data accessors. The library targets a wide range of .NET frameworks (netcoreapp3.0 through net8.0, plus .NET Framework 4.7+), reflecting its industrial compatibility requirements. Some parts of the codebase (the generic Tag<M,T> and associated PlcMappers) are marked obsolete due to a planned API redesign (referenced as issue #406), indicating ongoing evolution.
sqlite-net is a lightweight .NET ORM library for SQLite, providing both synchronous and asynchronous APIs. It maps C# classes to database tables via attributes, supports CRUD operations, LINQ-like queries, transactions, migrations, encryption (SQLCipher), and backup. The library is implemented in two main source files (SQLite.cs and SQLiteAsync.cs) and uses SQLitePCLRaw or P/Invoke to interface with native SQLite. It targets .NET Standard 2.0, .NET 8, and .NET 9, and is designed for cross-platform use including Xamarin, UWP, and desktop applications. The codebase is well-structured with performance optimizations like fast column setters and prepared statement caching, and includes a comprehensive test suite. It is actively maintained with recent commits and CI integration.
This repository is a production-grade FastAPI boilerplate (named 'Fastro') designed to accelerate building SaaS backends. It provides a complete, modular architecture with three layers: infrastructure (config, caching, rate limiting, auth, logging, database), interfaces (REST API, admin panel), and vertical-slice modules (user, tier, API keys, rate limits). The codebase is fully async, uses SQLAlchemy 2.0 with `MappedAsDataclass`, Pydantic v2, and FastCRUD for generic CRUD operations. Authentication is session-based via the external `crudauth` library, with server-side sessions, CSRF, OAuth (Google wired), and API key support. Caching and rate limiting follow a provider pattern with swappable Redis/Memcached backends. The repo also includes a CLI tool (`bp`) with plugin discovery for commands and features, a multi-stage Dockerfile, Alembic migrations, and extensive documentation (though some docs describe aspirational features not yet implemented). A paid fork (FastroAI) adds payments, email, and frontend, but the free boilerplate is self-contained and functional.
Legba is a production-grade multi-protocol credential bruteforcer, password sprayer, and enumerator written in Rust. It operates as a CLI tool with a plugin-based architecture supporting 30+ protocols (HTTP, SSH, SMB, LDAP, Kerberos, SQL variants, NoSQL, message queues, SNMP, etc.). The core system uses an async runtime (Tokio) and a global plugin inventory managed via a `register_plugin!` macro and the `Plugin` trait. Credential sources are generated by a flexible expression parser that supports wordlists, globs, permutations, ranges, and combinations. Sessions can be saved and restored in JSON format, and output supports text, CSV, and JSONL. In addition to CLI, Legba exposes a REST API and an MCP (Model Context Protocol) server, enabling AI agents to drive credential testing programmatically. A YAML recipe system allows reusable attack configurations with variable substitution.
fastapi-mail is a lightweight async Python library for sending emails from FastAPI/Starlette applications. It provides a clean, Pydantic-driven configuration model (ConnectionConfig), a message builder (MessageSchema) supporting HTML, plain text, Jinja2 templates, file attachments, CC/BCC/reply-to, and custom SMTP headers. The core FastMail class handles async SMTP delivery via aiosmtplib, with optional Redis-backed email validation utilities (DefaultChecker) and a WhoIsXmlApi wrapper. The architecture is simple and single-purpose: a library to be imported into FastAPI projects. It has comprehensive test coverage (22+ async tests) and modern async patterns throughout. The codebase is well-maintained with CI/CD, linting, and documentation. While the library does not exhibit groundbreaking innovation, it is a solid, production-ready solution for email sending in async Python web applications.
The ultimate-web-scraper repository is a comprehensive PHP toolkit for web scraping and related web interaction tasks. It provides a robust HTTP client (WebBrowser) that handles cookies, redirects, SSL/TLS, and proxy support, enabling reliable web requests. For HTML processing, it includes the TagFilter library, which offers high-performance parsing with CSS3 selector support, streaming capabilities for large files, and built-in XSS prevention. The toolkit also features WebSocket client and server implementations, a simple HTTP server, and utilities for asynchronous operations, DNS over HTTPS, and data streaming. Designed as a modular library, it allows developers to extract and reuse components like the HTTP client, HTML parser, or async helper in other projects with minimal dependencies.