Projects sharing features with Comlink

Greenlet is a multi-threaded asynchronous executor and web worker task runner. It serves as an execution wrapper that offloads heavy computation to background workers to maintain user interface responsiveness and prevent the main execution thread from blocking. The project includes a transferable object handler designed to move large data buffers between threads. This mechanism avoids the overhead of memory copying to optimize data transfer. The library covers the management of web workers, facilitating asynchronous task isolation and main thread offloading.

q is a JavaScript promise library and asynchronous flow controller designed to manage non-blocking operations. It serves as a system for coordinating parallel tasks and sequencing asynchronous workflows through task chaining and error propagation. The library distinguishes itself with specialized debugging tools that capture long stack traces across asynchronous jumps and monitor unhandled rejections to prevent silent failures. It also functions as a remote object proxy, forwarding method calls to remote targets and routing responses back through promises. The project provides comprehensive

This repository contains the HTML specification, which defines the core standards for web page structuring, content organization, and document rendering. It establishes the fundamental algorithms for state-machine-based tokenization, tree construction for the document object model, and origin-based security isolation. The specification provides a framework for defining custom elements with independent lifecycles and registries. It also details the requirements for cross-document communication, session history management, and the synchronization of interface properties with content attributes.

This project is an end-to-end type-safe API framework designed to synchronize data structures between frontend and backend codebases without the need for manual code generation. By leveraging TypeScript’s type inference, it allows developers to invoke server-side functions directly from the client as if they were local methods. This remote procedure call approach abstracts away the complexities of HTTP verbs and URL structures, streamlining the full-stack development workflow into a unified experience. The framework distinguishes itself through a modular router architecture that organizes bac

MagicOnion is a remote procedure call framework for the .NET platform and Unity. It functions as a binary API protocol and real-time communication engine that uses shared interfaces to provide type-safe communication between clients and servers. The framework distinguishes itself through its compatibility with ahead-of-time compilation environments, utilizing source generators for client proxies and serialization to support mobile and console platforms including those using IL2CPP. It provides a specialized middleware layer for Unity that handles engine-specific data types and ensures runtime

Livestore is a reactive state management framework that utilizes a local SQLite database to store and synchronize application data. It provides an event-sourced state store that processes typed events through materializer functions to derive and persist application state. The framework implements offline-first data synchronization using a push-pull engine and append-only event logs to maintain consistency between clients and servers. It includes a real-time presence system for tracking user activity and shared session status across connected clients. The system covers a broad capability surf

open62541 is an open-source implementation of the OPC Unified Architecture standard, providing a complete stack for industrial automation and data exchange. It functions as both an OPC UA server and client, enabling the creation of an object-oriented address space to model physical industrial assets and their relationships. The project is designed for versatility across diverse hardware, offering a C99 library that can be deployed to both cloud servers and resource-constrained embedded environments. It distinguishes itself through a pluggable network layer and interface-based security backend

Muuri is a JavaScript grid layout library and draggable UI framework used to create responsive grids with drag-and-drop reordering, sorting, and animated filtering. It features a nested grid system that allows full grid instances to be embedded inside other grid items to create hierarchical structures. The library uses a web worker layout engine to offload heavy coordinate calculations to background threads, maintaining interface responsiveness during complex rearrangements. The system provides interactive capabilities for moving items between multiple containers, filtering visibility based

grpcurl is a command-line interface and client tool for invoking gRPC methods and inspecting service definitions. It serves as a server debugger and reflection client, allowing users to call remote procedures and verify server responses from the terminal using JSON or protobuf formats. The tool distinguishes itself through the ability to discover available services and methods dynamically via a server reflection service or by loading local protobuf schema files. It can extract service descriptions from a server for local use and print specific schema symbol definitions. It covers a broad ran

Marshmallow is a Python data serialization library and validation framework. It functions as a bridge that transforms complex application objects into primitive data types for storage or network transmission and vice versa. The library utilizes a schema-based approach to validate that incoming data conforms to specific types and constraints. It employs a two-way transformation pipeline consisting of separate load and dump phases to handle deserialization and serialization. The framework supports class-based schema definitions with declarative field validation and recursive schema nesting for

localForage is a browser storage wrapper and key-value store that provides a unified JavaScript API for persisting data. It acts as an abstraction layer over IndexedDB, WebSQL, and localStorage, allowing web applications to save data offline. The library features a priority-based driver fallback system that automatically detects and selects the most capable storage engine available in the browser. It simplifies data management by providing an asynchronous interface for storing complex JavaScript objects and binary buffers without requiring manual serialization. The project covers broad capab

Anko is an Android Kotlin library designed to simplify application development through a set of domain-specific languages and extensions. It functions as a programmatic UI DSL, an SQLite wrapper, an SDK utility, and an asynchronous framework. The project provides a declarative layout system that allows developers to build user interfaces through code instead of static XML markup. It distinguishes itself by offering a fluent database layer that eliminates manual cursor management and a concurrency system that uses weak references to prevent memory leaks in activities. The library covers broad

tapkulibrary is a collection of reusable user interface elements and layout utilities for building native iOS applications. It provides a modular set of building blocks, including a custom graphics framework, networking toolkits, and specialized interface components. The library includes a dedicated media gallery component for creating 3D perspective coverflow galleries and swipeable lists, as well as a grid-based calendar interface for monthly event layouts and date selection. The toolkit covers asynchronous network communication, allowing for data request scheduling on background threads.

Ion is an asynchronous HTTP client library for Android that handles network requests, JSON parsing, image loading, and file downloads. It provides a fluent builder pattern for constructing requests and supports automatic JSON deserialization into Java objects using Gson, along with in-memory image caching and multipart form-data encoding. The library distinguishes itself through its support for request cancellation via Future objects, allowing individual or bulk cancellation of in-flight requests to avoid wasted bandwidth and stale callbacks. It also includes proxy-aware request routing for d

Superjson is a lossless JSON serialization library and data transcoder. It converts complex JavaScript and TypeScript data types into strings and metadata to ensure that type identity is preserved during data transfer. The library preserves non-native types such as Dates, Maps, and Sets by splitting values into a JSON-compatible payload and a separate map of type-specific metadata. It utilizes a registry-based mapping system that allows for the definition of custom type handlers to manage third-party data types during serialization and deserialization. This utility supports cross-process dat

SVGOMG is a browser-based SVG minification tool that applies SVGO transformations entirely on the client side. It processes SVG files in a Web Worker to keep the user interface responsive, then displays the original and optimized file sizes side by side, including gzipped size estimates. The tool provides a live preview of the optimized SVG markup, rendered directly in the browser for immediate visual feedback. Users can configure which SVGO optimization plugins are enabled or disabled, set numerical precision for coordinates and transforms, and optionally pretty-print the output. Multiple op

YYText is an iOS rich text framework used for rendering and editing complex attributed text. It features an asynchronous text rendering engine that calculates layout on background threads to maintain interface performance, alongside an attributed text serializer for converting rich text structures into storable formats. The framework provides specialized tools for non-rectangular text layout, allowing text to wrap around custom container paths and exclusion shapes. It also supports advanced typography requirements, including vertical text formatting for East Asian languages and the applicatio

Boost is a collection of portable, high-performance source libraries that extend the C++ standard library. It provides a wide range of reusable components, data structures, and algorithms designed to add capabilities to the base language across different platforms. The project is distinguished by its extensive focus on compile-time template metaprogramming and generic programming. It implements advanced architectural patterns such as policy-based design, concept-based type validation, and the use of SFINAE for conditional template resolution to minimize runtime overhead. The library covers a

This project is a sample library and implementation guide for using RxJava to manage asynchronous data streams and concurrent tasks in Android applications. It provides a collection of reference implementations for reactive programming, focusing on functional operators to transform and combine asynchronous data flows. The library demonstrates specific Android architectural patterns, such as implementing decoupled event buses for component communication and coordinating parallel network requests. It includes concrete examples of mobile-specific patterns including search input debouncing, list

brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port. The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio

Carlo is a Node.js web rendering framework and desktop application bundler. It functions as a server-side browser controller and headless automation bridge that uses a local browser instance as the primary user interface for Node.js applications. The project distinguishes itself by providing a bidirectional bridge for cross-environment JavaScript integration, allowing server-side functions to be exposed to the browser window object and enabling the execution of page-context code from the server. It includes capabilities for packaging applications into standalone desktop executables, complete

Embed PDF Viewer is a browser-based PDF rendering library that uses a WebAssembly port of the PDFium engine to display documents entirely on the client side, with no server-side processing required. It provides a framework-agnostic core engine layer that manages the PDF document lifecycle, memory allocation, and WebAssembly resource cleanup, with dedicated integration hooks for React and Vue 3 that handle initialization, document loading, and reactive state management. The library offers both a pre-built, embeddable viewer that can be inserted into any web page with a single initialization ca

canvas-confetti is an HTML5 canvas animation library and browser particle effect engine designed to render celebratory confetti bursts. It functions as a visual effects tool that transforms SVG paths, emojis, and text into animated particles. The library offloads heavy particle calculations to a web worker to maintain main thread responsiveness and prevent the user interface from lagging. It includes built-in support for operating system reduced motion settings, automatically disabling animations for users with motion sensitivities to ensure accessibility compliance. The system supports conf

This is an asynchronous HTTP client for Android that simplifies network requests by wrapping Apache HttpClient. It provides a callback-based networking library for fetching remote data and communicating with servers without blocking the user interface. The project includes a multipart HTTP uploader for sending binary files and large data payloads, as well as a JSON parser to convert raw response text into structured data objects. It features a session manager that persists cookies in local application preferences to maintain state across multiple requests. Additional capabilities include aut

This project is a .NET implementation of the gRPC framework, providing a system for executing functions on remote servers as if they were local calls. It serves as a high-performance remote procedure call (RPC) framework that utilizes HTTP/2 for service connectivity and binary communication protocols to ensure efficient data exchange. The implementation includes a gRPC-Web proxy, which acts as a translation layer to enable browser-based applications to communicate with gRPC services through web-compatible requests. It further supports the creation of HTTP/2 service meshes to connect distribut

fast-json-stringify is a high-performance JSON serialization library that uses JSON Schema to compile optimized functions for converting JavaScript objects into strings. It serves as a schema-based JSON serializer that generates specialized serialization logic to outperform standard stringification methods. The project provides capabilities to export standalone serialization code to files for direct execution and supports schema reference resolution to eliminate logic duplication. It allows for the deactivation of character escaping for trusted data to reduce overhead and includes specific op

Murder is an entity component system game engine designed for 2D game development. It provides a core framework for managing game objects through an ECS architecture and includes a dedicated 2D game editor for asset management and real-time property configuration. The engine features a specialized 2D rendering pipeline supporting pixel art, sprite slicing, and parallax effects. It includes a hierarchical A* pathfinding system for agent navigation and a comprehensive asset management system for serializing and loading game resources. The project covers a broad range of capabilities, including