Einops is a Python library that provides a uniform, readable, and reliable API for tensor manipulation across multiple deep learning frameworks (NumPy, PyTorch, TensorFlow, JAX, and others). It uses Einstein-like notation (e.g., 'b c h w -> b h w c') to express axis reordering, composition, decomposition, reduction, and repetition in a single, explicit string. The library is built around a core transformation engine that parses axis patterns into a cached 'TransformRecipe', which is then applied via a backend abstraction layer. This architecture allows einops to support 10+ frameworks with minimal code duplication, while also providing framework-specific layer wrappers (Rearrange, Reduce, EinMix) for seamless integration into model definitions. The library is designed for production and research use, with a focus on reducing errors from manual view/permute/transpose operations.
Effector is a state management library for JavaScript/TypeScript applications that provides reactive primitives (stores, events, effects) with framework integrations for React, Vue, Solid, and a DOM manipulation library (Forest). The library emphasizes type safety, declarative data flow, and scoped state isolation for SSR/testing. Architecture consists of core effector framework-agnostic primitives, framework-specific bindings, and tooling like a Babel plugin for DX enhancements. Key entry points include src/effector/index.ts (core API), packages/effector-react/index.ts (React bindings), and packages/forest/index.ts (Forest UI engine). Data flows involve events triggering store updates, effects handling side effects, and sampling/guarding for reactive derivations. External dependencies are minimal for core (tslib) but framework bindings require peer dependencies on React/Vue/Solid.
JSX Pragmatic is a JavaScript library that enables developers to write JSX templates without being coupled to a specific rendering framework. Unlike traditional JSX usage which is typically tied to React through Babel presets, this library separates the JSX parsing from the rendering process, allowing developers to decide at runtime how and where to render their JSX components. The core innovation lies in its node-based architecture where JSX elements are converted into a tree of framework-agnostic node objects (ElementNode, TextNode, ComponentNode, FragmentNode). These nodes can then be rendered by different renderer functions to various targets including HTML strings, DOM elements, React components, Preact components, or even custom outputs like regular expressions. This approach provides unprecedented flexibility for isomorphic applications that need to render the same component definitions to different targets. The library includes specialized components that demonstrate its versatility, such as a regex-building DSL that uses JSX syntax to construct regular expressions, and a Style component for injecting CSS. With comprehensive test coverage and active maintenance, JSX Pragmatic serves as a robust solution for projects requiring multiple rendering targets from a single JSX source.
unplugin-icons is a universal build tool plugin that enables on-demand import of thousands of SVG icons as framework-specific components. It integrates with Vite, Webpack, Rollup, Nuxt, Rspack, and esbuild via the unplugin abstraction. The core architecture consists of a loader that resolves icon paths (e.g., `~icons/mdi/account`), fetches SVG data from Iconify or custom collections, and passes the SVG through a compiler that generates code for Vue 3, React/JSX, Svelte, Solid, Astro, Ember, Qwik, Web Components, or raw SVG strings. Options allow customization of scale, style, class, icon customizer, and auto-install of icon sets. The resolver module enables auto-importing icons as components in Vue/React/Solid projects via unplugin-vue-components or unplugin-auto-import. The codebase is well-structured, with clear separation between build tool adapters, core logic, and compilers. It relies on external dependencies like @iconify/utils for SVG loading and optional peer dependencies for framework-specific compilation.
This repository is a framework-agnostic drag-and-drop library developed by FormKit. It provides a data-first approach where consumers manage a reactive array as the source of truth, and the library handles DOM reordering internally. The core is written in TypeScript and is small (~4KB gzip), with first-class adapters for React, Vue, Solid, and Marko. The architecture consists of a central state machine using WeakMap stores to associate DOM elements with drag state, an event emitter pattern for global and parent-level events, and a plugin system for extensibility (animations, drop-or-swap, insert). Key entry points include the `dragAndDrop` function and framework-specific hooks/composables (e.g., `useDragAndDrop` for React). The library supports native HTML drag-and-drop and synthetic pointer-based dragging for touch devices, with features like multi-drag, drag handles, shadow DOM, and configurable animations. External dependencies are minimal—only peer dependencies for framework adapters and optional Marko runtime. The repository also includes a comprehensive Playwright test suite covering sorting, transfer, animations, and edge cases, plus a Nuxt-based documentation site with live examples for all supported frameworks.
Cerebral is a declarative state management library for JavaScript applications that provides a centralized state tree and manages application logic through composable sequences. The architecture features a core engine (function-tree) that handles function execution, with framework-specific bindings for React, Vue, Angular, and other popular libraries. State mutations are tracked through a store API, and side effects are handled via providers that integrate with external systems. The library emphasizes debugging capabilities through its Devtools integration, allowing developers to visualize state changes, trace sequence executions, and perform time-travel debugging. Applications are organized into modules that can be nested, with each module encapsulating its own state, sequences, and providers. Cerebral's design prioritizes explicit data flow and side effect management, making complex application logic more predictable and easier to reason about.