Open-source alternatives to Css Modules

styled-jsx is a CSS-in-JS library and styling framework for JSX components. It functions as a scoped CSS engine that uses compile-time transformations to generate unique class names, preventing style leakage between components. The system includes a server-side CSS renderer that flushes styles into HTML to prevent layout flicker during the first paint. It ensures security compliance by attaching per-request nonces to generated style tags to satisfy Content Security Policy requirements. The framework covers global CSS management with deduplication, dynamic styling via template interpolation,

Rollup is an ES module bundler and JavaScript module transpiler. It functions as a build tool that combines JavaScript modules into optimized files and converts modern JavaScript and JSX into various output formats for different runtime environments. The project is distinguished by its static-analysis tree shaking engine, which removes unused code and dead exports to minimize bundle size. It also acts as a code splitting orchestrator, partitioning modules into separate chunks to optimize network requests and load times. The tool provides a hook-based plugin system for extending build logic,

Ripple is a full-stack TypeScript web framework and reactive UI library used for building interfaces with server-side rendering. It organizes user interfaces into a hierarchy of reusable, scoped components with built-in state management and client-side hydration. The framework is distinguished by its fine-grained reactivity, which updates specific DOM elements without requiring full component re-renders. It integrates server-side logic and client-side components within a single TypeScript codebase, enabling a unified full-stack development workflow. The system covers a broad range of capabil

vanilla-extract is a type-safe CSS-in-JS library and zero-runtime CSS framework. It uses TypeScript to define styles and design tokens, compiling these definitions into static CSS files during the build process to eliminate styling overhead in the browser. The system acts as a scoped CSS generator, producing unique class names and local variables to prevent global style leakage and naming collisions. It provides a type-safe styling tool that validates CSS property values and ensures design tokens adhere to defined themes during development. The framework covers comprehensive styling utilitie

Riot is a component-based library for building user interfaces through modular, single-file components. It functions as a framework for creating reusable elements that combine markup, logic, and scoped styles, which are then compiled into standard JavaScript functions for browser execution. The library distinguishes itself by utilizing direct rendering, which updates the document object model by tracking state changes without the overhead of a virtual representation. It supports server-side rendering and hydration to improve initial page load performance and search engine indexing. Developers

styled-components is a CSS-in-JS styling library and tool for React components. It provides a cross-platform UI styling API and a dynamic theme management system to maintain consistent design tokens and encapsulate visual logic, preventing global scope conflicts. The library utilizes a unified interface that works across both web environments and native mobile frameworks. It enables the definition of styles using JavaScript and TypeScript template literals, allowing CSS to be bound directly to components. The system supports dynamic prop-based styling, style inheritance, and the creation of

This project is a high-performance static type checker and comprehensive development toolkit for Python. It functions as a core analysis engine that identifies type inconsistencies and enforces code correctness, while simultaneously providing a language server implementation to deliver real-time diagnostics and intelligence directly within development environments. The tool distinguishes itself through a parallelized execution engine that maximizes performance across large-scale codebases and monorepo structures. It supports gradual type adoption, allowing developers to integrate type checkin

wepy is a frontend build toolchain and component framework designed for creating mini programs. It provides a modular UI library and a system for building reusable interface elements that maintain consistent layouts across different platform environments. The project features a cross-platform build target system that maps a single source codebase to multiple distinct output formats. It utilizes a template-based compilation process to transform custom syntax into platform-specific markup and supports the integration of third-party JavaScript packages through asynchronous module resolution. Th

High performance, maintainable stylesheets.

Tamagui is a cross-platform user interface framework designed to build high-performance, themeable applications that share logic and styling across web and mobile environments. It functions as a comprehensive design system orchestrator, providing a collection of type-safe components that compile to optimized atomic CSS for the web and native code for mobile platforms. By utilizing a build-time compiler, the framework eliminates runtime overhead, ensuring consistent visual output and interaction behavior regardless of the target platform. The framework distinguishes itself through its advanced

Maven is a Java build automation tool and software build orchestrator. It functions as a project lifecycle manager and dependency management system, using a standardized project object model to compile, test, and package Java projects. The project distinguishes itself through a phase-based build lifecycle and a plugin-based extension model, allowing users to bind custom goals to specific build stages. It coordinates complex software through multi-module project orchestration and ensures a reproducible build workflow by neutralizing environmental variables and controlling toolchain versions.

Umi is a comprehensive React application framework and enterprise frontend toolchain. It provides a plugin-based build system and a configuration-driven routing engine to integrate routing, build tooling, and deployment within a single dependency. The project serves as a micro-frontend orchestrator, coordinating multiple independent frontend applications into a single interface with shared data flow. Its extensible architecture allows for the customization of every stage of the application development lifecycle through a system of plugins. The framework covers a broad range of enterprise cap

Hatch is a unified tool for managing Python environments, building packages, scaffolding projects, and installing Python versions. It provides a single command-line interface for automating common development workflows, including running scripts, tests, and static analysis with automatic dependency resolution and configuration. The tool manages project settings, dependencies, and build instructions through a declarative TOML configuration file, ensuring reproducibility across environments. It creates and manages isolated virtual environments across all major shells, installs and manages multi

Craco is a configuration layer for Create React App that modifies Webpack and Jest settings without requiring the project to eject. It functions as a build tool plugin system and configuration manager, allowing for the injection of custom settings and third-party logic into the frontend build pipeline. The project utilizes a hook-based architecture and non-destructive configuration merging to override default settings. This allows for Webpack configuration overrides and Jest configuration tuning while maintaining the original source files. The system covers a broad range of build pipeline ex

Microbundle is a zero-configuration JavaScript module bundler designed to package small libraries and modules into optimized distribution files. It serves as a JavaScript library packager and TypeScript compiler, converting source code into compatible module formats for both browser and server-side runtimes. The tool functions as a bundle size optimizer by mangling object properties and analyzing bundle composition to reduce final file sizes. It also acts as a CSS module processor, converting style imports into external stylesheets or scoped modules to prevent global namespace collisions. It

Svelte is a compile-time user interface framework that transforms declarative component syntax into highly optimized, imperative JavaScript code during the build process. By shifting reconciliation logic from the browser to the build step, it functions as a zero-runtime library that eliminates the need for a heavy framework bundle. This architecture relies on a reactive state management paradigm where data changes trigger surgical updates to the document object model without the use of a virtual representation. The framework distinguishes itself through a reactive dependency tracking system t

react-basic provides a conceptual implementation of the React model, focusing on a component-based UI architecture. It employs pure functions to transform raw data into structural interface representations and uses a declarative system for managing UI state and hierarchical data distribution. The project distinguishes itself through specialized caching strategies, including tree-based result caching that stores values based on the structural position of elements. It also features a mechanism for deferred function execution to remove boilerplate from business paths and supports the isolation o

esm is an ECMAScript module loader and JavaScript module path resolver. It functions as a runtime system that executes standard JavaScript modules without requiring a separate build or bundling process. The project provides a compatibility bridge for CommonJS interoperability, wrapping CommonJS exports into synthetic modules to allow imports and exports between different module systems. It includes a dynamic module cache that stores resolved instances in memory to prevent redundant file system reads and repeated execution. The system handles runtime path resolution and file extension detecti

swagger-core is a set of libraries for parsing, generating, and serializing OpenAPI specifications to automate REST API documentation. It provides tools to read, validate, and transform JSON or YAML specifications into programmable objects, as well as a generator that scans source code and annotations to create formal technical descriptions of an API. The project enables bi-directional specification serialization, allowing in-memory API definitions to be converted between native language objects and structured files. It uses a plugin-based scanning mechanism and annotation-driven generation t

This project is a styling library and framework designed for component-based architectures, enabling developers to define and manage visual styles directly within JavaScript or TypeScript. It functions as a styling engine that generates unique class names from style definitions, ensuring encapsulated, predictable, and maintainable visual presentation across applications. By integrating with component logic, it allows for the creation of reusable UI elements with styles defined through template literals or object syntax. The library distinguishes itself through a comprehensive suite of build-t

Bun is a high-performance runtime environment designed to execute JavaScript and TypeScript applications with minimal latency and high throughput. Built on a native core implemented in Zig, it provides a unified execution engine that leverages JavaScriptCore for efficient memory management and low-latency startup. The project functions as an all-in-one toolchain, integrating a native bundler, transpiler, package manager, and test runner into a single command-line interface. What distinguishes Bun is its focus on native system integration and developer productivity. It features a high-performa

Buttons is a CSS button framework and UI component library providing a set of reusable visual elements for mobile and desktop web environments. It functions as a CSS utility system and variable-driven theming engine that enables the creation of consistent buttons using configurable typography and shapes. The system utilizes a modular CSS architecture where independent style and color classes are composed on single elements to produce varied visual effects, such as 3D or flat designs. It employs a declarative design framework that maps configuration options to real-time visual attributes via c

This project provides a collection of instructional guides and tutorials for Android app development, native mobile application creation, and computer science education. It focuses on building native applications through step-by-step implementation, covering the development of user interfaces and the integration of system hardware and permissions. The material extends into broader technical domains, including the study of fundamental data structures and algorithms for technical interview preparation. It also covers cybersecurity fundamentals, such as identifying web vulnerabilities and implem

SketchyBar is a shell-scriptable system user interface and status bar replacement for macOS. It replaces the native menu bar with a customizable overlay that uses scriptable widgets and dynamic visual blocks to display real-time data. The tool is distinguished by its use of external shell scripts to update visual elements and state. It supports a declarative configuration system that allows for the creation of multi-instance bars and the execution of batched commands to minimize flickering during startup. The system provides capabilities for dynamic system monitoring through graphs and visua

Get BEM to all people in simplest way

Metro is a JavaScript bundler designed for React Native environments. It functions as a system for resolving dependencies, transforming source code, and packaging JavaScript and assets into bundles for execution. The project includes a development bundler server that hosts assets via HTTP and provides hot module replacement. It features a module resolver that handles platform-specific file extensions and a source code transformer that converts code into tree structures for optimization and minification. The toolset covers programmatic bundle generation, source map creation, and file system c

Kibo is a registry-based UI framework and accessible web interface library that distributes modular components as raw source code. It functions as a collection of utility-styled building blocks and headless UI primitives that separate complex state management and accessibility logic from visual presentation. The project utilizes a source-code distribution model, allowing components to be fetched and injected from a centralized registry directly into a local project directory. This approach enables full ownership of the code and the ability to customize component logic and visual styles. The