facebookarchive/AsyncDisplayKitArchived

Features

• Declarative Layout Engines - Builds user interfaces by composing layout specifications and nested containers based on a box model.
• Flexbox Layout Engines - Provides a declarative layout engine based on a flexbox model to calculate element positions and sizes asynchronously.
• Flexbox Layout Models - Implements a declarative layout system based on a flexbox model to automate sizing and positioning.
• Flexbox and Grid Layouts - Specifies the size and position of UI elements using a flexbox model for asynchronous measurement.
• Asynchronous Loading - Performs image fetching and decoding on background threads to maintain smooth UI scrolling.
• Asynchronous Layout Calculation - Computes the size and position of interface elements on background threads to prevent main thread freezes.
• Asynchronous UI Frameworks - Provides a complete framework for building responsive iOS interfaces by offloading layout and rendering.
• iOS UI Components - Offers a collection of performant alternative UI components for lists, buttons, and rich text.
• List Scrolling Optimizations - Builds complex lists and grids with asynchronous row height calculation and data preloading for seamless browsing.
• UI Performance Libraries - Reduces main thread blocking through asynchronous image decoding and text rasterization.
• Scroll-Based Resource Loading - Triggers data fetching and layout calculations automatically as elements approach the visible viewport during scrolling.
• Background Thread Dispatchers - Routes the computation of interface positions and sizes to background threads to prevent main thread locking.
• Concurrent UI Construction - Instantiates and configures user interface components in parallel on background threads.
• Logic and Presentation Separation - Decouples data preloading and business logic from view classes using dedicated controller-managed node lifecycles.
• UI Thread Responsiveness - Offloads layout and rendering tasks to background threads to prevent frame drops.
• Asynchronous Image Decoding - Decodes image data on background threads to prevent the main thread from blocking during UI updates.
• Asynchronous Remote Image Fetching - Fetches images from URLs on background threads to prevent interface blocking.
• Collection Rendering - Generates repeated UI elements for grids and lists using asynchronous layout and rendering.
• Composition Hierarchies - Handles the addition and removal of subnodes automatically based on the layout requirements of a parent node.
• View Hierarchies - Hosts a node-based view hierarchy within a view controller to enable asynchronous layout and rendering.
• Dimension Definitions - Specifies element sizes using fixed point values, relative percentages, or automatic resolution.
• Element Stacking - Positions children in horizontal or vertical stacks using a flexbox algorithm.
• High-Performance Rendering - Produces high-frame-rate views by offloading rendering tasks to eliminate dropped frames.
• Layout Composition Frameworks - Defines relationships between UI elements using container specifications to arrange children in stacks or overlays.
• Linear Layouts - Arranges elements in horizontal or vertical stacks with configurable spacing and flexible growth behaviors.
• Asynchronous Rendering - Offloads image decoding and text rasterization to background threads to eliminate frame drops during scrolling.
• Network Image Renderers - Fetches and displays images from remote web addresses while handling caching and progressive loading.
• View Controller Lifecycle Management - Integrates asynchronous interface components into the standard view controller lifecycle.
• Sizing Constraints - Sets preferred, minimum, and maximum widths and heights for layout elements to control space occupancy.
• Virtual View Abstractions - Uses a node-based abstraction to wrap native views, allowing UI hierarchies to be configured on background threads.
• Visibility-Based Resource Management - Intelligently adjusts memory and data loading priorities based on the visibility depth of view controllers.
• Automatic Node Hierarchy Management - Determines the presence of subnodes based on the layout specification to remove manual node management.
• Flexbox Layout Patterns - Adjusts how children grow, shrink, and align within a stack, including flex basis and baseline alignment.
• Main Thread Offloading - Offloads view property configuration and construction to background threads to maintain UI responsiveness.
• UI Transition Animations - Creates fluid animations and interpolations between different layout states during content changes.
• Network Image Caching - Stores downloaded images in a local cache to minimize redundant network requests.
• Preloading - Proactively fetches data from disks or APIs when UI elements enter a predefined proximity range.
• Scroll-Based - Loads content and assets ahead of the current scroll position to ensure a seamless browsing experience.
• Batched Data Loading - Triggers background data loading in batches as the user scrolls toward the end of a list.
• Image Transformations - Applies visual effects and drawing operations to images on background threads to avoid UI stutters.
• Asynchronous Image Effects - Executes image transformations such as rounding and overlays on background threads before final display.
• Asynchronous Video Rendering - Displays video assets using a performant layer that maintains main thread responsiveness.
• Layer-Backed Rendering Optimization - Switches nodes from view-based to layer-based rendering to reduce overhead for non-interactive components.
• UI Overlay Layers - Creates layered interfaces by placing layout elements directly on top of one another.
• Animated GIF Playback - Renders animated GIF files loaded from remote sources within the user interface on iOS.
• Visibility-Based Resource Management - Automatically reduces data fetch and display ranges of child components when views move off screen.
• Layer-View Wrapping - Encapsulates standard view subclasses within a node abstraction to integrate traditional components into an asynchronous system.
• Layout Interpolators - Calculates and animates the difference between two layout specifications to smoothly reposition elements.
• Background Display Preparation - Executes text rasterization and image decoding in the background as elements approach the visible area.
• Component Insets - Wraps a child element with a specified margin on each edge to create padding around content.
• Layer Flattening - Flattens complex node trees into single composited layers to reduce rendering overhead.
• Aspect Ratio Constraints - Scales components based on a fixed ratio relative to the available width or height.
• Element Centering - Positions child elements within available space based on specified horizontal and vertical centering options.
• Element Positioning - Places child elements at specific bounds such as corners, edges, or the center of the layout area.
• Absolute Positioning - Allows precise placement of elements using exact X and Y coordinates within a layout.
• Hybrid Synchronous-Asynchronous Cells - Integrates standard collection cells and asynchronous nodes within a single collection view for flexible rendering.
• Layout Alignment Utilities - Aligns elements centrally along X or Y axes using specific sizing constraints.
• Layout Animation Engines - Smoothly transitions the size and position of interface elements during bounds changes or device rotation.
• Layout Insets - Adds padding around a component or a group of elements to create margins between content and edges.
• Layout Transition Libraries - Animates changes between different layout states and provides the ability to cancel transitions.
• Dynamic Item Size Calculators - Automatically calculates the scrollable area of a view based on its internal layout specification.
• Overlay Components - Places elements directly on top of others, stretching the overlay to match the base child's dimensions.
• Collection Cell Constraints - Defines size boundaries for individual items within a collection to control layout growth and shrinkage.
• Mixed-Node Cell Integration - Integrates standard collection cells alongside asynchronous nodes to enable incremental migration from traditional view controllers.
• Rich Text Renderers - Renders attributed strings with custom styling, truncation, and interactive hyperlinks.
• Interaction Depth Calculation - Calculates the number of user interactions required to make a view controller visible to adjust resource usage.
• Dynamic Height Calculation - Provides automatic determination of list item heights based on content constraints to eliminate manual calculations.
• Visibility State Transitions - Executes custom logic through callbacks as UI elements transition between preloading, display, and visible states.
• Progressive Image Loading - Implements perceived loading speed improvements by swapping low-resolution placeholders for high-resolution versions.
• View-Layer Hybrid Rendering - Reduces rendering overhead by switching components between view-based and layer-based modes for non-interactive elements.
• Custom Cell Subclassing - Supports the creation of flexible cell components for tables, collections, and pagers through custom subclassing.
• Viewport Proximity Tracking - Determines the proximity of view controllers to the screen to manage content loading and visibility.
• Visibility-Driven Resource Management - Reduces data and image ranges of views as they move deeper into the navigation stack to optimize memory.
• Viewport Visibility State Tracking - Triggers callbacks when nodes enter or exit visibility states to optimize the timing of resource loading.
• Viewport-Based Preloading - Triggers layout measurement and data fetching in the background before elements enter the visible viewport.

Star history