# tamagui/tamagui

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/tamagui-tamagui).**

13,729 stars · 585 forks · TypeScript · mit

## Links

- GitHub: https://github.com/tamagui/tamagui
- Homepage: https://tamagui.dev
- awesome-repositories: https://awesome-repositories.com/repository/tamagui-tamagui.md

## Topics

`atomic-css` `css-in-js` `optimizing-compiler` `react` `react-native` `react-native-web` `tailwind` `typescript` `ui` `ui-components` `vite` `webpack`

## Description

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 style compilation and component flattening capabilities, which replace nested component wrappers with direct native primitives to reduce tree depth and improve rendering performance. It features a unified styling system that maps design tokens to CSS variables, enabling dynamic theme switching and responsive layout adaptation without triggering expensive runtime re-renders. Additionally, it includes interchangeable animation drivers that translate declarative motion logic into platform-specific APIs, maintaining consistent transitions across different operating systems.

Beyond its core styling and rendering engine, the project provides a suite of tools for managing complex interface states, including headless logic for accessibility and portal-based management for overlays. It supports a scalable approach to design system engineering, allowing for the definition of global tokens, typography, and nested color themes that propagate automatically throughout the component tree. The framework also includes a command-line interface to automate development workflows, from component compilation and configuration validation to project lifecycle management.

## Tags

### User Interface & Experience

- [Cross-Platform UI Frameworks](https://awesome-repositories.com/f/user-interface-experience/cross-platform-ui-frameworks.md) — Provides a high-performance, themeable framework for building consistent user interfaces across web and mobile platforms.
- [React Components](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-libraries/react-components.md) — Ships a collection of composable, type-safe interface elements that share a unified styling system across web and native environments.
- [Design Systems](https://awesome-repositories.com/f/user-interface-experience/design-systems.md) — Provides a comprehensive design system orchestrator for defining global tokens, typography, and themes that propagate across components.
- [Dynamic Theming](https://awesome-repositories.com/f/user-interface-experience/dynamic-theming.md) — Applies nested, variable-based themes that compile to style sheets to support responsive design without runtime re-renders. ([source](https://tamagui.dev))
- [CSS Scoping Engines](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/styling-architectures/styling-systems/build-time-style-processing/css-scoping-engines.md) — Compiles component-level style definitions into optimized atomic CSS to minimize bundle size and runtime overhead.
- [Color Themes](https://awesome-repositories.com/f/user-interface-experience/color-themes.md) — Manages and generates color palettes that automatically adapt to system-level appearance preferences. ([source](https://tamagui.dev/theme/1980/black-and-white-hi-contrast))
- [Component Composition](https://awesome-repositories.com/f/user-interface-experience/component-architectures/component-composition.md) — Assembles styled, headless, and themeable components using a composable API for consistent design. ([source](https://tamagui.dev))
- [Component Compilers](https://awesome-repositories.com/f/user-interface-experience/component-utilities/ui-frameworks/component-libraries/react-components/component-compilers.md) — Optimizes component trees by replacing nested wrappers with direct native primitives during the build process.
- [CSS Variable Theming](https://awesome-repositories.com/f/user-interface-experience/css-variable-theming.md) — Enables dynamic theme switching by mapping design tokens to CSS variables without triggering expensive re-renders.
- [Design Tokens](https://awesome-repositories.com/f/user-interface-experience/design-token-management/design-tokens.md) — Configures global design values including color palettes, opacity levels, and responsive breakpoints for consistent styling. ([source](https://tamagui.dev/blog/version-two))
- [Flexbox Layouts](https://awesome-repositories.com/f/user-interface-experience/flexbox-layouts.md) — Arranges interface elements using flexible container layouts that support standard styling and spacing for responsive designs. ([source](https://tamagui.dev/ui/stacks))
- [Overlay Components](https://awesome-repositories.com/f/user-interface-experience/overlay-components.md) — Mounts floating overlay components like dialogs and tooltips at the application root using scoped portals. ([source](https://tamagui.dev/blog/version-two))
- [Platform-Adaptive UI Elements](https://awesome-repositories.com/f/user-interface-experience/platform-adaptive-ui-elements.md) — Adjusts component structure and appearance dynamically based on screen size or the underlying operating system. ([source](https://tamagui.dev/docs/intro/introduction))
- [Styled Properties](https://awesome-repositories.com/f/user-interface-experience/styled-properties.md) — Integrates custom component properties directly into the styling and animation system for theme-aware visual updates. ([source](https://tamagui.dev/docs/core/styled))
- [Static Style Extraction](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/styling-architectures/styling-systems/build-time-style-processing/static-style-extraction.md) — Compiles component styles into atomic CSS or native style objects during the build process to eliminate runtime overhead.
- [Atomic CSS Generators](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/styling-architectures/styling-systems/class-based-styling/css-styling/atomic-css-generators.md) — Converts component styling syntax into atomic CSS during the build process to minimize bundle size and runtime overhead. ([source](https://tamagui.dev))
- [Typography Systems](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/typography-and-iconography/typography-systems.md) — Configures scalable typography with precise control over vertical rhythm and weight using a fully typed system. ([source](https://tamagui.dev))
- [Theme Configuration Systems](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/design-utilities/design-systems/theme-architecture-frameworks/theme-configuration-systems.md) — Establishes contextual color palettes that nest and swap throughout the component tree for dynamic theme support. ([source](https://tamagui.dev/docs/core/configuration))
- [Theme State Managers](https://awesome-repositories.com/f/user-interface-experience/ui-state-management/theme-state-managers.md) — Tracks changes to design tokens and responsive breakpoints using granular updates to trigger efficient re-renders. ([source](https://tamagui.dev/docs/intro/introduction))
- [Animation and Motion Systems](https://awesome-repositories.com/f/user-interface-experience/animation-and-motion-systems.md) — Orchestrates smooth, state-based motion and transitions that behave consistently across web and mobile platforms.
- [Component Composition Primitives](https://awesome-repositories.com/f/user-interface-experience/component-architectures/component-composition/component-composition-primitives.md) — Assembles complex application layouts using modular primitives that encapsulate behavioral logic and structural properties. ([source](https://tamagui.dev/bento))
- [Cross-Platform Animation Engines](https://awesome-repositories.com/f/user-interface-experience/cross-platform-animation-engines.md) — Provides interchangeable animation drivers that translate declarative motion logic into platform-specific APIs.
- [Responsive Layouts](https://awesome-repositories.com/f/user-interface-experience/responsive-layouts.md) — Provides layout primitives that automatically adapt to different screen sizes and platform-specific interaction patterns.
- [Component Styling Tools](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/component-styling-tools.md) — Encapsulates functional components to ensure consistent inheritance and merging of styles, themes, and properties. ([source](https://tamagui.dev/docs/core/styled))
- [Component Styling](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/component-styling-tools/component-styling.md) — Provides shorthand property mapping to standard style attributes to accelerate component styling and reduce code verbosity. ([source](https://tamagui.dev/docs/core/configuration))
- [Element Tag Overrides](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/component-styling-tools/component-styling/element-tag-overrides.md) — Allows developers to override the underlying HTML or native element rendered by a component for structural flexibility. ([source](https://tamagui.dev/docs/core/styled))
- [Styling Variants](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/component-styling-tools/styling-variants.md) — Enables creation of conditional style sets that allow components to change appearance based on property values or tokens. ([source](https://tamagui.dev/docs/core/styled))
- [UI State Management](https://awesome-repositories.com/f/user-interface-experience/ui-architecture/immediate-mode-ui-development/ui-state-management.md) — Provides a root-level configuration provider to manage shared state and portal rendering for complex interface elements. ([source](https://tamagui.dev/ui/intro))
- [Visual Themes](https://awesome-repositories.com/f/user-interface-experience/visual-themes.md) — Switches between predefined color palettes and design tokens to maintain consistent styling across application states. ([source](https://tamagui.dev/blog))
- [Component Transitions](https://awesome-repositories.com/f/user-interface-experience/component-transitions.md) — Triggers specific entry and exit animations for components as they are added to or removed from the document tree. ([source](https://tamagui.dev/docs/core/animations))
- [Custom Theme Definitions](https://awesome-repositories.com/f/user-interface-experience/custom-theme-definitions.md) — Enables the definition and refinement of custom color palettes and design tokens through configuration. ([source](https://tamagui.dev/theme/1951/ocean-blue-theme))
- [Headless UI Components](https://awesome-repositories.com/f/user-interface-experience/headless-ui-components.md) — Decouples accessibility and state management from visual styling to ensure consistent behavior across implementations.
- [Styling Systems](https://awesome-repositories.com/f/user-interface-experience/styling-theming-systems/content-styling/styling-architectures/styling-systems.md) — Implements complex visual properties like gradients and filters using token-based shorthand for consistent styling. ([source](https://tamagui.dev/blog/version-two))
- [Overlay Management](https://awesome-repositories.com/f/user-interface-experience/overlay-management.md) — Mounts floating elements like dialogs and tooltips at the application root to maintain structural integrity.
- [Granular Animation Controls](https://awesome-repositories.com/f/user-interface-experience/transition-effects/granular-animation-controls.md) — Allows customization of animation timing, delays, and easing on a per-property basis for complex motion effects. ([source](https://tamagui.dev/docs/core/animations))

### Development Tools & Productivity

- [Bundle Size Optimization](https://awesome-repositories.com/f/development-tools-productivity/bundle-size-optimization.md) — Optimizes bundle size by hydrating styles directly from CSS variables during server-side rendering. ([source](https://tamagui.dev/docs/core/configuration))

### Web Development

- [Cross-Platform Styling](https://awesome-repositories.com/f/web-development/cross-platform-styling.md) — Defines interface elements using a unified styling interface that renders consistently across web and native environments. ([source](https://tamagui.dev/docs/intro/introduction))
- [Component Flattening](https://awesome-repositories.com/f/web-development/tree-shaking-optimizers/component-flattening.md) — Replaces complex wrapper components with native primitives to reduce tree depth and improve rendering performance. ([source](https://tamagui.dev/docs/intro/why-a-compiler))
- [Universal Style Compilers](https://awesome-repositories.com/f/web-development/cross-platform-styling/universal-style-compilers.md) — Converts shared style definitions into platform-optimized code for web and native environments to ensure consistent visual performance. ([source](https://tamagui.dev/takeout))
- [Component State Management](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/component-lifecycle-utilities/component-state-management.md) — Implements headless hooks for complex interface elements to handle accessibility and navigation logic independently of styling. ([source](https://tamagui.dev/blog/version-two))
- [Server-Side Hydration Utilities](https://awesome-repositories.com/f/web-development/server-side-hydration-utilities.md) — Integrates themes, animations, and responsive styles into the initial payload to ensure consistent visual rendering during hydration. ([source](https://tamagui.dev))
- [Component Composition](https://awesome-repositories.com/f/web-development/component-composition.md) — Allows developers to build reusable user interface elements by extending existing components with custom styles and variants. ([source](https://tamagui.dev/docs/core/styled))
- [Request Routing](https://awesome-repositories.com/f/web-development/request-routing.md) — Routes application requests by matching file paths to content, supporting server-side rendering and static generation. ([source](https://tamagui.dev/takeout))
- [Style Normalizers](https://awesome-repositories.com/f/web-development/style-normalizers.md) — Maps a unified property shorthand system to platform-specific style attributes for consistent visual output.

### Software Engineering & Architecture

- [Cross-Platform Rendering](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/performance-optimization/frontend-rendering-loading/rendering-optimizations/cross-platform-rendering.md) — Compiles components into native code or lightweight web alternatives to ensure smooth performance across platforms. ([source](https://tamagui.dev/blog/version-two))
- [Dynamic Style Compilation](https://awesome-repositories.com/f/software-engineering-architecture/performance-reliability/performance-optimization/frontend-rendering-loading/rendering-optimizations/dynamic-style-compilation.md) — Converts media queries and theme logic into static CSS variables during the build process to prevent expensive runtime re-renders. ([source](https://tamagui.dev/docs/intro/why-a-compiler))

### Programming Languages & Runtimes

- [End-to-End](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety/end-to-end.md) — Validates data structures across the entire stack using integrated schema definitions to prevent runtime errors. ([source](https://tamagui.dev/takeout))

### Data & Databases

- [Real-time Data Synchronization](https://awesome-repositories.com/f/data-databases/real-time-data-synchronization.md) — Maintains consistent application state across clients and servers using optimistic updates for responsive experiences. ([source](https://tamagui.dev/takeout))