Yoga

Yoga is a cross-platform layout engine and embeddable core that determines the dimensions and offsets of hierarchical element trees. It provides a C++ implementation of the Flexbox layout model to calculate element positions and sizes based on web standards, ensuring a uniform appearance across diverse devices and operating systems.

The engine is designed for portability via a C API, allowing the layout logic to be integrated into various host languages and platforms. It utilizes an incremental layout system that identifies modified subtrees and recalculates positions only for changed nodes and their ancestors to avoid full tree recomputation.

The library covers a broad range of layout capabilities, including the application of box model styling with margins, padding, and borders. It resolves dimensions using absolute points or percentages and manages a tree-based hierarchy to propagate constraints and calculate relative positioning.

Features

Cross-Platform Layout Engines - Provides a portable engine for determining dimensions and offsets of element trees across diverse platforms.

Flexbox Layout Engines - Provides a Flexbox layout engine for aligning and distributing elements within containers using responsive properties.

Cross Platform Layout Libraries - Provides a cross-platform library that brings flexbox layout capabilities to non-web environments.

UI Hierarchy Organizers - Structures UI elements into parent-child stacks for nested container management and constraint propagation.

UI Tree Layout - Implements an incremental layout system that only recalculates modified subtrees and their ancestors.

Flexbox and Grid Layouts - Implements the flexible box model for geometric computation of element positioning in non-browser environments.

Layout Tree Construction - Allows the creation and linking of nodes to establish a hierarchical structure for UI elements and styling.

Layout Engines - Provides a layout engine to calculate the size and position of UI elements based on constraints.

Incremental Calculation - Calculates positions only for modified nodes and their ancestors to avoid full tree recomputation.

Incremental Layout Systems - Flag nodes with changed layout results to skip updates for unchanged branches of the user interface tree.

Layout & Positioning - Determines the final spatial arrangement and dimensions of visual elements in a hierarchical tree.

Embeddable Core APIs - Offers a C API to integrate the layout core into various host languages and target platforms.

Embeddable Cores - Ships as a portable layout library with a C API for integration into various host languages.

CSS Box Model Renderers - Calculates element dimensions, margins, and padding according to the CSS box model.

Constraint-Based - Implements solvers that determine component dimensions and positions based on a set of defined rules and constraints.

Incremental Layout Engines - Implements an incremental layout engine that updates only modified nodes and their ancestors.

C++ Core Implementations - Provides a high-performance core written in C++ with a C API for embedding across different platforms.

Dirty Flagging Systems - Uses dirty-flagging mechanisms to mark nodes needing updates and optimize layout re-calculation.

Layout Metric Extraction - Allows the extraction of resolved dimensions, offsets, and spacing values from nodes after layout computation.

Box Sizing Configurations - Manages how element dimensions are calculated relative to padding and borders to ensure uniform spacing.

Relative Layout Dimensions - Processes layout sizes using absolute points and relative dimensions to maintain consistency across screens.

reactyoga

Features

Star history